Point optimisation: how to

[mixedgas]

I wish it were so easy as to just go to dual files. When you get into dealing with multiple brands and speeds of Galvo, you find the current system is very sane. Going to dual files just does not matter much now that newer Galvos are starting to hit their physical speed limits.
(Ie a high end Saturn @ 90 Kpps is about as fast as you can go before the shaft bends or shows horrible torsional resonances)

The current method forces all users to have about the same capacity and the ability to see what they are interchanging. It also allows for enough flexibility to allow for WAV file use and low cost DACs with 5$ processing chips to use SD cards.

Take a look at what Beyond outputs with the stock ILDA files. If you look at it from a quality standpoint, what it does with the old Data is amazing, and its vector processing techniques allow you to really push what the Galvos can do. The "Automagic" is there, at least in that program.

LSX is no slouch in creating "Automagic" optimized vectors, either. I was just displaying very nice animations with marking Galvos with a 1 inch by 1 inch square, 1/8th inch thick mirror. I was rather shocked. Then I realized the marking Galvo Amps did have a complex limiter circuit, so they were not going to try to display anything they could not follow in the time domain. So while the show looked fine, the ILDA test Pattern was impossible. Beam shows with little dwell on the single beams did not look so hot, either.

Yes, you can add a few more analog functions to a scanner amp to avoid "overexciting" the galvo. However its not so easy to implement this as a standard. The analog method degrades beam shows, so again, best to do this in software.

Steve

[Grix]

So how exactly does one calculate the max travel distance between points and the amount of dwell on corners?

[colouredmirrorball]

That's the golden question isn't it.
The ideal values are different for each projector. Thus software usually has a setup somewhere where you can edit these values.

Usually the sharper the angle the more dwell points.

LSX lets you precisely control the minimum interpolation distance for various settings (blanked line, "soft colour", ...) and the amount of dwell points at transitions (beginning, end, blank <-> unblank animation) but only has a limited corner dwell point option which can only be enabled in animations and text.

Maybe the super secret vector display settings are Quickshow's optimisation settings.

[james]

LaserBoy puts vertices along straight lines based on the settings in the [Tab] menu:

3 max optimized lit vector in points
4 max optimized blank vector in points

Those points are relative to the coordinate space; -32767 to +32767 in thee axes.

LB looks at the magnitude (length) of the vector and figures out equidistant steps, each less than or equal to the set value.

To do dwell you need to know the angle of approach and departure for every vertex.

Dwell is a number of vertices at the exact same coordinate location, all the same color and lit.

LaserBoy lets you mess around here too. You can have some blank dwell.

The number of added vertices is based on time, in microseconds. The number you set in the [Tab] menu

5 max dwell in microseconds

is what you get for an angle of 180 degrees.

When setting this value, you also have to consider the value of

h output wave sample rate

because this is the clock that microseconds is connected to.

If you want to optimize art for a diferent kind of DAC, you could set this to the DAC clock rate; like 20000 for a 20K DAC.

Even if you never make a wave file, the art will still be optimized for 20K.

If you make a wave it will have a sample rate, set in the header, of 20K and your wave player app and sound card driver would up-sample it. So it would work much the same as a 20K DAC.

[colouredmirrorball]

So I noticed that some people, me included, are currently writing programs that output ilda files and have optimisation options (or will have).
Now it might be a good idea to make this uniform. My idea is to design a file format that defines optimisation settings, so you can transport them seamlessly over all programs. Instead of having to go through the headache of optimising output in each program (which might or might not do dac output which makes this even more time consuming), you'd just do it once and then transport the settings to other programs. You could also have multiple optimisation files (one for beams, one for graphics, one for abstracts, one for really complicated abstracts etc) and when you're not happy with one, just edit it and transport it to the other programs instead of doing all the changes again manually.

I'm just a beginner and know nothing of "best practices" and stuff like that so if you have a better idea please share!

This is my proposal:

A text file with extension ".opt"

#Optimisation file proposal
#Comments are indicated with #
#All values are in units of distance where 1 is equal to 1/65536 of the width or height of the screen (like in an ilda file)
#All angles are in degrees



#DATA REDUCE
data_reduce = true

#Remove points that are on the same line
remove_collinear_points = true

#Remove points that are more or less on the same line
collinearity_tolerance = false

#Remove points that would have been collinear if they were moved with this distance or less towards the line
collinearity_tolerance_distance = 1

#Remove points that are within the reach defined by this angle
#Angle measured in degrees and is the total angle (so in this case, all points that are in the area defined by the two lines at an angle of 2.5° from the line)
collinearity_tolerance_angle = 5

#Remove consecutive identical points 
remove_identical_points = true

#Remove all blanked points which aren't on the same location as a lit point
remove_unnecessary_blanked_points = true

#Remove all points with an intensity below this value (where 1 is maximum)
intensity_offset = 0.001



#INTERPOLATION
interpolation = true

#The maximum distance between two lit points
interpolation_distance = 100

#Interpolate blanked points
interpolation_blanked = true

#the maximum distance between two blanked points
interpolation_blanked_distance = 100



#ANGLE DWELL

angle_dwell = true

#Defines how many points should be added when an angle is encountered
#Angles are measured in degrees, and is the angle between the previous point, current point and next point
# angle : points added
#These values define a reach so angles in [0..10[ degrees get 6 points, angles in [10..20[ get 5 etc.
#These intervals aren't fixed, a program could add or remove intervals
begin_angle_dwell:
0 : 6
10 : 5
20 : 5
30 : 4
40 : 4
50 : 3
60 : 3
70 : 3
80 : 3
90 : 3
100 : 2
110 : 2
120 : 1
130 : 1
140 : 1
150 : 0
160 : 0
170 : 0
180 : 0
end_angle_dwell




#TRANSITION DWELL
transition_dwell = true

#Adds points at the beginning of the frame
begin_point_dwell = 2

#Adds points at the end of the frame
end_point_dwell = 2

#Adds extra points at the blank -> unblank transition
blank_to_lit_dwell = 2

#Adds extra points to the unblank -> blank transition
lit_to_blank_dwell = 2

It's very likely I forgot about some parameters.

What do you think? Good idea or not?

[james]

LB has a plain ASCII text file format that is a collection of all of the settings of the application. This file is not to be directly edited. It is made and read by the running app. These files are in the wtf folder and have the .wtf extension. You can save and open any name for different system settings.

The LaserBoy wave file header extensions also include a chunk of data that is the parameter set used to make the wave.

It should not be difficult to implement the idea.

The trick is to come up with a set of parameters that are truly universal.

I think you will find there are different ways to do things that require a different set of parameters.

Laser art optimization is an art; not so much a standard science.

You might think my ideas for optimizing are bunk. That's OK! There are many ways to do it.

James.

[BlueFang]

So I noticed that some people, me included, are currently writing programs that output ilda files and have optimisation options (or will have).
Now it might be a good idea to make this uniform. My idea is to design a file format that defines optimisation settings, so you can transport them seamlessly over all programs. Instead of having to go through the headache of optimising output in each program (which might or might not do dac output which makes this even more time consuming), you'd just do it once and then transport the settings to other programs. You could also have multiple optimisation files (one for beams, one for graphics, one for abstracts, one for really complicated abstracts etc) and when you're not happy with one, just edit it and transport it to the other programs instead of doing all the changes again manually.

I'm just a beginner and know nothing of "best practices" and stuff like that so if you have a better idea please share!

This is my proposal:

A text file with extension ".opt"

#Optimisation file proposal
#Comments are indicated with #
#All values are in units of distance where 1 is equal to 1/65536 of the width or height of the screen (like in an ilda file)
#All angles are in degrees



#DATA REDUCE
data_reduce = true

#Remove points that are on the same line
remove_collinear_points = true

#Remove points that are more or less on the same line
collinearity_tolerance = false

#Remove points that would have been collinear if they were moved with this distance or less towards the line
collinearity_tolerance_distance = 1

#Remove points that are within the reach defined by this angle
#Angle measured in degrees and is the total angle (so in this case, all points that are in the area defined by the two lines at an angle of 2.5° from the line)
collinearity_tolerance_angle = 5

#Remove consecutive identical points 
remove_identical_points = true

#Remove all blanked points which aren't on the same location as a lit point
remove_unnecessary_blanked_points = true

#Remove all points with an intensity below this value (where 1 is maximum)
intensity_offset = 0.001



#INTERPOLATION
interpolation = true

#The maximum distance between two lit points
interpolation_distance = 100

#Interpolate blanked points
interpolation_blanked = true

#the maximum distance between two blanked points
interpolation_blanked_distance = 100



#ANGLE DWELL

angle_dwell = true

#Defines how many points should be added when an angle is encountered
#Angles are measured in degrees, and is the angle between the previous point, current point and next point
# angle : points added
#These values define a reach so angles in [0..10[ degrees get 6 points, angles in [10..20[ get 5 etc.
#These intervals aren't fixed, a program could add or remove intervals
begin_angle_dwell:
0 : 6
10 : 5
20 : 5
30 : 4
40 : 4
50 : 3
60 : 3
70 : 3
80 : 3
90 : 3
100 : 2
110 : 2
120 : 1
130 : 1
140 : 1
150 : 0
160 : 0
170 : 0
180 : 0
end_angle_dwell




#TRANSITION DWELL
transition_dwell = true

#Adds points at the beginning of the frame
begin_point_dwell = 2

#Adds points at the end of the frame
end_point_dwell = 2

#Adds extra points at the blank -> unblank transition
blank_to_lit_dwell = 2

#Adds extra points to the unblank -> blank transition
lit_to_blank_dwell = 2

It's very likely I forgot about some parameters.

What do you think? Good idea or not?

I am all for coming up with a pseudo standard... however, one thing I would strongly suggest is to use a different format for this data serialization - something that is a bit more structured and widely supported - like JSON or YAML (or XML - yuck) - but just a flat text file is heading down the path you mentioned of "bad practices".

Everyone can read JSON these days - it is structured and human readable - it supports arrays of things as well as dictionaries (or maps), as well as both floating point and integers.

The problem with using a flat text file of kvp (key value pairs) - is that whoever ingests this file needs to create their own custom parser, instead of relying on some standardized type of parsing and data format.

JSON or YAML or XML - but not flat KVP

[james]

How would you go about "standardizing" optimization technology?

How could you be sure that you were using your parameters with the same kind of math as they are used in some other app?

I had to figure out how to get the results that I have in LB. I had no methods or code from anywhere else.

And like I said, my ideas might not make you happy. I would imagine that the techniques of today will be outdated some day.

There isn't even a standard for saving optimized art; let alone parameters for making it!

I've tried to move in that direction with my wave file extensions.

A wave file is logically connected to time. An ILDA file is not.

James.

[BlueFang]

How would you go about "standardizing" optimization technology?

James.

You don't... but you can create a way to exchange optimization values (or hints). Obviously, optimization is something that is completely dependent on the DAC technology as well as scanner performance.

I see it similar to the way true-type font technology works. Glyphs have hinting properties - which font rendering engines can use to optimize and improve on font rasterization and layout - however, they don't "have" to be used - they can be ignored.

[BlueFang]

This is what your flat file would look like converted to JSON:

{
  "point_optimization_version" : "0.0.1",
  "data_reduction": {
    "collinearity_tolerance": false,
    "collinearity_tolerance_distance": 1,
    "collinearity_tolerance_angle": 5,
    "remove_identical_points": true,
    "remove_unnecessary_blanked_points": true,
    "intensity_offset": 0.001
  },
  "scanner_optimization" : {
    "interpolation": {
      "interpolation_distance": 100,
      "interpolation_blanked": true,
      "interpolation_blanked_distance": 100
    },

    "angle_dewll": [
      [0,10,6],
      [11,20,5],
      [21,50,4],
      [51,100,3],
      [101,120,2],
      [121,150,1],
      [151,180,0]
    ],
    "transition_dwell": true,
    "begin_point_dwell": 2,
    "end_point_dwell": 2,
    "blank_to_lit_dwell": 2,
    "lit_to_blank_dwell": 2
  }
}

Another advantage of using a well-defined format, is that you get syntax coloring for free! I like syntax coloring!
optimi-json.png