Showing posts with label swift. Show all posts
Showing posts with label swift. Show all posts

Wednesday, January 15, 2020

Hello World, from MathPaint! (Preview)

If you've been following Mathaesthetics posts you've seen a variety of images shared - different types of generated art from fractals to repeated 2D plots to vector fields and scalar fields and more.

All images on this blog are created by our flagship software product, which has been in development since November 2019. Today for the first time I'm publicly sharing some screenshots of the user-interface, starting with a few document windows:

Hello World, from MathPaint!

These MathPaint documents were used to create our app icon and current Facebook cover.

MathPaint is a Mac OS desktop application written in Swift. A private beta release is planned for February 2020, and the completed 1.0 application will be released later this year, through the Apple AppStore.

CoreImage effects can be applied to any MathPaint canvas
I've always felt that creativity and mathematics belong together. MathPaint is designed for creative professionals who would like to harness of of the endless generative capability of mathematics to create visual forms, patterns, textures, and algorithmic art. You don't need to be a programmer to create such designs with MathPaint, and the release will include visual templates and presets that are intuitive to browse and modify, plus cool automation features:

The "Repeater" feature can add multiple iterated re-renderings to a model

I also think MathPaint is a natural tool for students. While there are robust software products for mathematical modeling and computation, MathPaint focuses on aesthetics and uniquely permits the creative impulse to guide mathematical learning and exploration.

I will be using MathPaint to make art, and I hope to see a community of makers who create original expressive work with this software. Even algorithmic artists used to coding may find some rewarding features and workflows with this tool.

Document settings give you a page-layout app's control over your math-art canvas.

Now that the first screenshots are out, look for weekly updates and posts on MathPaint progress! And of course, a continuing stream of art, including our Fractal Friday posts, all made by MathPaint.



Friday, January 10, 2020

Fractal Friday 2020.01.10

ICYMI, I'm currently writing an application that generates mathematical art. It's created in Swift, for Mac OS desktop systems. All the images on this blog are created from it, including the fractals posted every Fractal Friday.

This week I hooked up a full range of CoreImage effects to the app, and I'm having fun sending fractals through tiling effects to create some really cool repeating patterns.

For the first one I used a small 320x320 source image of an edge-rendered Julia set section

I played around with this image using the Twelvefold Reflected Tile and Eightfold Reflected Tile filters to get these:




I used a more psychedlic-looking color-banded Mandelbrot section for the next set:


Friday, December 27, 2019

Fractal Friday 2019.12.27

It's the last Fractal Friday of the year, time for some recursive magic!

 This week we're exploring the Mandelbrot set, using two features of the Mathaesthetics prototype software: deep color mapping, and a new helpful zoom feature.

Here's where we start:
In this image, there's a color mapping with 10 different colors at various levels of iteration-result, from 1 to 300. This is both a more diverse color mapping and deeper-iteration delve than I've done before, although you can't tell yet from the image above. Here's a screenshot of the prototype app, showing the higher-end of the color mapping assignments and other settings:



The colors at 1 and 300 are the same (a deep dark blue), and you mostly just see gradations to the orange color set for iteration level 20 above. We have to zoom in to start seeing the other iteration levels, especially those that take over 100 or 200 iterations to hit the breakout threshold of 10.0.

Fortunately I hooked up a new UI feature this week, a click-and-drag zoom feature that lets me zoom to a tiny (but still aspect-ratio-preserving) part of the image.

Series A zooms toward (-1.075885, 0.2433465)




Zoom series B ends up around (-0.766362, 0.1001006)



Zoom series C ends up in the region of (-1.94310614143, 0.001727529425)






More images PLUS a software release to come in 2020! Happy new year. You can follow Mathaesthetics on Twitter, Facebook, and Instagram.

Monday, December 23, 2019

Dev notebook: an enum alternative to GKState / GKStateMachine

I worked on my first GameplayKit project earlier this year and there were things I liked about the lightweight, general state-machine model provided by the GKState and GKStateMachine classes. However I also found a few odd patterns in these classes: their implementation without using enumeration values for states, the inelegant (StateClass).class.self syntax model required by the state machine enterState() method, and the update() interface which I found extra and somewhat orthogonal to the pure function of the state machine (I keep time-based concerns in entities and components).

In my current project, which is not a game, I wanted to use a pattern similar to GKStateMachine for various UI and model states, but decided to implement a simple framework that addressed these issues rather than use GKStateMachine.

The basic pattern is provided by a protocol that *could* be implemented by any class, but the interface strongly suggests that a state will be an enum : Int type:


protocol MPState {
    var rawEnumValue : Int { get }
    var validNextStates : [Int] { get }
    
    func didEnter(from prevState: MPState?, with machine: MPStateMachine)
    func willExit(to nextState: MPState?, with machine: MPStateMachine)
}


Obviously the rawEnumValue will be very easy to implement as a wrapper on rawValue if the state is implemented as an enum : Int rather than some other type of struct or class. Also, the required validNextStates computed property is expected to return values that can be compared with rawEnumValue for inclusion/exclusion, and this logic is made explicit in an extension to the protocol (which also implements didEnter and willExit as no-ops to make them optional):


extension MPState {
    func isValidNextState(_ nextState : MPState, 
                          with machine: MPStateMachine) -> Bool {

        return self.validNextStates.contains(nextState.rawEnumValue)
    }
    
    func didEnter(from prevState: MPState?, with machine: MPStateMachine) {
        // no-op, override to handle
    }
    
    func willExit(to nextState: MPState?, with machine: MPStateMachine) {
        // no-op, override to handle
    }
}


One thing this pattern precludes: the state object itself can't retain any persistent reference to either the state machine or any model object, since enumerations in swift can't have stored properties. This is handled by simply passing the machine object into the three relevant methods; the machine is a full-fledged class which also has an optional model property that can bring in more object context.


The state-machine class provides an interface like that of GKStateMachine, but instead of passing a class to the enter() method you can just pass your enumerated state value. It has a similar currentState read-only computed property (returning a private machineState value which can only be updated by successful enter). Here's the entire implementation:

class MPStateMachine : NSObject {
    var model: Any? = nil
    
    var currentState : MPState? {
        get {
            return self.machineState
        }
    }
    
    func canEnterState(_ nextState : MPState) -> Bool {
        if nil != self.machineState {
            return self.machineState!.isValidNextState(nextState, with: self)
        }
        return true // assume we can enter any state from nil
    }
    
    func enter(_ state: MPState) -> Bool {
        var setState : Bool = false
        if self.machineState == nil {
            self.machineState = state
            state.didEnter(from: nil, with: self)
            setState = true
        } else if self.machineState!.isValidNextState(state, with: self) {
            let oldState = self.machineState!
            self.machineState?.willExit(to: state, with: self)
            self.machineState = state
            state.didEnter(from: oldState, with: self)
            setState = true
        }
        return setState
    }
    
    fileprivate var machineState : MPState? = nil

}

The model property in the state machine is up to the client code to define; it will typically be the model object whose state is being managed, i.e. the domain-specific owner of the state machine instance.

As a sample implementation I created an MPApplicationState which tracks the app states of starting, running, terminating, owned by my AppDelegate class. This demonstrates the pattern of how valid next-states can be handled by a simple switch statement for most state collections, but you could always add helper methods for various state-transition contexts for more complex cases that need to inspect the model:

enum MPApplicationState : Int, MPState {

    case starting
    case running
    case terminating
    
    var rawEnumValue: Int {
        get {
            return self.rawValue
        }
    }
    
    var validNextStates: [Int] {
        get {
            var nextStates : [Int] = []
            switch self {
                case .starting:
                    nextStates.append(MPApplicationState.running.rawValue)
                    nextStates.append(MPApplicationState.terminating.rawValue)
                case .running:
                    nextStates.append(MPApplicationState.terminating.rawValue)
                case .terminating:
                    nextStates.removeAll()
            }
            return nextStates
        }
    }
    
    func didEnter(from prevState: MPState?, with machine: MPStateMachine) {
        print ("*** MPApplicationState *** did enter state: \(String(describing:self)) from \(String(describing:prevState))")
    }
    
    func willExit(to nextState: MPState, with machine: MPStateMachine) {
        print ("*** MPApplicationState *** will exit state: \(String(describing:self)) to state: \(String(describing:nextState))")
    }

}

Just to show the functionality (not really because it's useful) I created an MPStateMachine property on my AppDelegate (allocated at the declaration), and transition states in the following method overrides:

func applicationWillFinishLaunching(_ notification: Notification) {
    _ = self.stateMachine.enter(MPApplicationState.starting)

}


func applicationDidFinishLaunching(_ aNotification: Notification) {
    _ = self.stateMachine.enter(MPApplicationState.running)
    // etc...
}

func applicationWillTerminate(_ aNotification: Notification) {

    _ = self.stateMachine.enter(MPApplicationState.terminating)
}

I'm not bothering to check the output values for these simple cases but the idea is that more involved state transitions could do so, and/or pre-check the ability of the state machine to transition with a call a like:


   self.stateMachine.canEnterState(MPApplicationState.running)

And now checking the current application state looks a bit nicer than it would with GKStateMachine:

    if appDelegate.stateMachine.currentState != MPApplicationState.terminating {

        // do something...

That's it!

Tuesday, December 17, 2019

Scalar fields for gradients and other graphic patterns

The Mathaesthetics flagship app will support a number of modes of mathematical image creation. I spent most of yesterday working on and improving the scalar field renderer.

In a scalar field, a function f(x, y) produces a value for each point. This scalar value is then mapped to a color gradient. I'm exploring both different modes of color assignment and different function definitions and the results they yield.

Here's a simple example, of the function f(x, y) = x • y. The color scale is white-to-black, and here I'm only allowing 16 different distinct shades:

Here's the same function with the color mapping changed to orange-to-blue:

And again, but with the discrete shading limit removed so we get a smooth gradient:

Producing gradients that aren't simply linear or radial is one potential graphic application of scalar fields with algebraic functions. For example, a logarithmic gradient...

Saturday, November 30, 2019

Dev notebook: brush-like drawing in Swift, without CGPattern

I'm spending a lot of time in Cocoa drawing and Core Graphics lately, working in Swift.

The API around the Core Graphics CGPattern object in Swift is a little challenging - it requires C callbacks and unsafe pointers for basic pattern-creation and drawing functionality. It also doesn't work exactly as I'd like it to; I want to have more of a 'brush' metaphor where I can vary the 'paint' flow of the pattern being used to draw a line or a curve. But I definitely want a pattern-like construct that I can apply different stroke and fill colors to in order to draw.

My solution is to use NSImage, which is really convenient because it's a high-level object in Swift that can easily be created in memory or loaded from a .png resource in the app bundle.

The approach: given an NSImage that represents your brush pattern, create a copy NSImage that is rendered in the desired stroke color, then use that copy to draw your desired lines and curves, or tile it along with clipping to fill an area. I'll include an example of drawing a line with varying density, and of filling an area with clipping and offset adjustment.