🎞️ 2022.12.23 - beta!

🎞️ 2022.10.29 - color spaces 🤕

🎞️ 2022.09.29 - gallery performance

import math

from PySide6 import QtWidgets, QtCore


class FlowLayout(QtWidgets.QLayout):

    item_list: list[QtWidgets.QLayoutItem]
    horizontal_space: int
    vertical_space: int
    margin: int

    current_size: tuple[int, int]
    item_width: int
    item_height: int

    def __init__(self, parent: QtWidgets.QWidget, item_width: int, item_height: int):
        super().__init__(parent)

        if parent is not None:
            self.setContentsMargins(0, 0, 0, 0)

        # spaces between each item
        self.horizontal_space = 5
        self.vertical_space = 5
        self.item_width = item_width
        self.item_height = item_height

        self.item_list = []

        self.current_size = (0, 0)

    def __del__(self):
        item = self.takeAt(0)
        while item:
            item = self.takeAt(0)

    def addItem(self, item):
        self.item_list.append(item)

    def count(self) -> int:
        return len(self.item_list)

    def itemAt(self, index) -> QtWidgets.QLayoutItem | None:
        if index >= 0 and index < len(self.item_list):
            return self.item_list[index]

        return None

    def takeAt(self, index: int) -> QtWidgets.QLayoutItem | None:
        if index >= 0 and index < len(self.item_list):
            return self.item_list.pop(index)

        return None

    def addWidget(self, widget: QtWidgets.QWidget):
        super().addWidget(widget)

    def expandingDirections(self) -> QtCore.Qt.Orientations:
        return QtCore.Qt.Orientations(QtCore.Qt.Orientation(0))

    def hasHeightForWidth(self) -> bool:
        return True

    def heightForWidth(self, width: int) -> int:
        if width == 0:
            return -1

        # TODO take into account the right most horizontal_space
        column_count = max([width // self.item_width, 1])
        row_count = math.ceil(len(self.item_list) / column_count)

        height = row_count * (self.item_height + self.horizontal_space)

        # if even, remove last spacing
        if len(self.item_list) % 2 == 0:
            height -= self.vertical_space

        return height

    def setGeometry(self, rect: QtCore.QRect):

        super().setGeometry(rect)
        self.place_items(rect)

    def sizeHint(self) -> int:
        return self.minimumSize()

    def minimumSize(self) -> int:
        size = QtCore.QSize()

        for item in self.item_list:
            size = size.expandedTo(item.minimumSize())

        return size

    def place_items(self, rect: QtCore.QRect):

        if (rect.width(), rect.height()) == self.current_size:
            return

        self.current_size = (rect.width(), rect.height())
        column_count = max([rect.width() // self.item_width, 1])

        centering_offset = (rect.width() - (column_count * self.item_width)) // 2

        row = 0
        column = 0
        for item in self.item_list:
            x_offset = column * self.item_width + centering_offset
            y_offset = row * self.item_height

            column += 1
            if column == column_count:
                column = 0
                row += 1

            item.setGeometry(QtCore.QRect(x_offset, y_offset, self.item_width, self.item_height))

🎞️ 2022.09.28 - sauce and white balance

 

 

 

 

 

 

 

🎞️ 2022.09.27 - packaging for distribution cont’d

🎞️ 2022.09.25 - packaging for distribution

• opens the Gallery

• loads up all the imported folders in the explorer

• displays images in the Gallery for selected folders

• opens the Process page for a selected image

🎞️ 2022.09.24 - project board

1. late October for an MVP I can share about to get beta testing

2. mid November for a 1.0 product launch (including infrastructure around distributing app)

• Rotate images

• Set the sample space

• Set the “sauce” - individual tweaks to the cyan, magenta, and yellows across highlights, midtones, shadows, and globally

⏳ 2022.09.24 - getting back into it

💰 2022.09.16 film cameras + redispatcher updates

🎞️ 2022.09.07 - quick updates

🎞️ 2022.09.05 - gallery progress

• Imports (with a sick progress bar) any folders, their children, and contained images

• Persists them in a SQLite database

• Displays the images of any selected folder and its children

• I want to optimize importing images. With a large import (my import of my entire “Scans” folder of 1500+ images takes a while, with each image taking ~0.25 seconds to complete. The bulk of this time is spent generating the preview image. I will have the process thread kick off further threads for image resizing.

• When showing images for the gallery, I currently need to hackily fetch all the folders and all the images, the retrieval of which takes some time. I believe that it’s due to a bug in p3orm that doesn’t correctly construct parametrized queries for SQLite. I’ll need to fix this so I can more efficiently fetch just the folders I want.

• I need to make things look pretty. I’m going to ask for someone with product design skills to help me come up with a theme, palette, and overall design system.

• Toolbar on the right side - image and folder metadata like film type, format, etc; batch processing tools; exporting; and more.

• Navigation between screens and a proper menubar (particularly for macOS)

🎞️ 2022.09.02 - foundation

Initialization

Long running work

🎞️ 2022.08.31 - sqlite support in p3orm

🎞️ 2022.08.30 - slight change of plans

• electron or nw.js - fairly bulky, but also would require figuring out how to simultaneously spin up a Python server to do the image processing and that just seemed messy

• Eel - actually not super against this one, but I wanted to explore more than web technology for UIs (though I see myself coming back to this in the future)

• Tkinter - just looks ugly

• Kivy - still not huge on kvlang (lack of intellisense, mostly) and also because it’s basically all drawn on OpenQL and doesn’t use native UI bindings it won’t look truly native on each platform

• PyQT - has an unfavorable-for-commercial GPL v3 license

🚴 2022.08.28 - CitiBike, an addendum

🚴 2022.08.28 - CitiBike

import asyncio
from datetime import datetime, timedelta

import httpx
import uvloop
from p3orm import Porm

from citibike.models.db import Run, Station, StationStatus
from citibike.models.gql import CitiBikeResponse
from citibike.settings import Settings

request = httpx.Request(
    "POST",
    "https://account.citibikenyc.com/bikesharefe-gql",
    json={
        "query": "query {supply {stations {stationId stationName siteId bikesAvailable ebikesAvailable bikeDocksAvailable location {lat lng}}}}"
    },
)

run_count = 1


async def run():

    global run_count
    run_time = datetime.utcnow()
    print(f"""starting run {run_count} @ {(run_time - timedelta(hours=4)).strftime("%c")}""")

    await Porm.connect(dsn=Settings.DATABASE_URL)

    run = await Run.insert_one(Run(time=run_time))

    async with httpx.AsyncClient() as client:
        response = await client.send(request)

    data = CitiBikeResponse.parse_obj(response.json())

    for cb_station in data.data.supply.stations:
        station = await Station.fetch_first(Station.citibike_id == cb_station.station_id)

        if not station:
            station = await Station.insert_one(
                Station(
                    citibike_id=cb_station.station_id,
                    site_id=cb_station.site_id,
                    name=cb_station.station_name,
                    latitude=cb_station.location.lat,
                    longitude=cb_station.location.lng,
                )
            )

        await StationStatus.insert_one(
            StationStatus(
                station_id=station.id,
                bikes_available=cb_station.bikes_available,
                ebikes_available=cb_station.ebikes_available,
                docks_available=cb_station.bike_docks_available,
                run_id=run.id,
            )
        )

    await Porm.disconnect()


async def daemon():
    global run_count
    while True:
        asyncio.ensure_future(run())
        await asyncio.sleep(5 * 60)
        run_count += 1


if __name__ == "__main__":
    uvloop.install()
    asyncio.run(daemon())

📓 2022.08.27 - devlog CDN

from io import BytesIO

import httpx
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from PIL.Image import open as pil_open

app = FastAPI()

MEMORY: dict[str, BytesIO] = {}


@app.get("/")
async def get_resource(image_url: str):

    if image_url in MEMORY:
        buffer = MEMORY[image_url]

    else:
        async with httpx.AsyncClient() as client:
            response = await client.get(image_url)

            image = pil_open(BytesIO(response.content))
            image = image.convert("RGB")
            buffer = BytesIO()
            image.save(buffer, format="jpeg", quality=80)

            MEMORY[image_url] = buffer

    buffer.seek(0)
    return StreamingResponse(buffer, media_type="image/jpeg")

🎞 2022.08.26 - basic processing ✅

1. Film base color selection which the server uses to remove the color cast on the image

2. Cropping out the film border for the server to get the right sample to do its color science on

3. The colloquially named “sauce”, which controls the cyan, magenta, and yellow presence in the image (I’ve broken these out into global, highlight, midtone, and shadow changes)

 🎞 2022.08.17 - film scan editor

1. Digital asset management (DAM). I should be able to upload a bunch of negatives, have them be treated like a cohesive roll of film (tagging things with EXIF/metadata like what camera I used, what film this is, what format, etc.)

2. Non-destructive editing. I don’t want the changes I make to be baked into the image. Instead, all changes, no matter after how many weeks later I come back, should be easily undo-able without quality/data loss of the image. This also means support for raw image formats straight from the camera (thank you rawpy).

3. Batch processing. If I process a frame from a roll, it stands to reason that I should be able to apply those base settings to all the other images from that roll. This should get me 90% of the way with all the images in a roll with minimal effort.

4. Negative conversion feature. i.e. the ability to turn an orange inverted image into something that looks passable.

5. Additional editing features. To start, I’m thinking at least:
1. blemish (read: dust/scratch) removal
2. (AI powered) sharpening
3. HSL/color tweaking
4. And of course, the basic stuff like cropping, exposure, contrast, etc.

📓 2022.08.16 - initial commit

• Fetch content from a Notion page using their “private” API and

• Render (virtually) every available block with a React component

import { GetStaticProps, GetStaticPropsContext } from 'next'
import { NotionAPI } from 'notion-client'
import { ExtendedRecordMap } from 'notion-types'
import { NotionRenderer } from 'react-notion-x'
import NextImage from 'next/image'
import NextLink from 'next/link'
import styled from '@emotion/styled'

const devlogPageId = 'redacted even though it doesnt really matter'

interface Props {
  recordMap: ExtendedRecordMap
}

export default function BlogPage (props: Props): React.ReactElement {
  return (
    <Wrapper>
      <NotionRenderer
        recordMap={props.recordMap}
        fullPage={false}
        darkMode={false}
        rootPageId={devlogPageId}
        rootDomain='raf.al'
        previewImages
        components={{
          nextLink: NextLink,
          nextImage: NextImage
        }}
        mapPageUrl={(pageId) => pageId.replace(/-/g, '') === devlogPageId ? '/devlog' : `/devlog/${pageId.replace(/-/g, '')}`}
      />
    </Wrapper>
  )
}

export const getStaticProps: GetStaticProps = async (context: GetStaticPropsContext) => {
  const notion = new NotionAPI({
    activeUser: process.env.NOTION_USER,
    authToken: process.env.NOTION_TOKEN
  })

  const recordMap = await notion.getPage(devlogPageId)

  return {
    props:
    {
      recordMap: recordMap
    },
    revalidate: 10
  }
}

const Wrapper = styled.div`
  min-height: 100vh;
  width: 100%;
`