Mediachance

Oscar

Scanning Negatives with Bellows

by

If you want to scan negatives at home there are few options. The most common these days is to use flatbed scanner with a negative attachment (which is basically a light inside the lid and some sort of plastic negative holder). Then there are dedicated film scanners that usually produce sharper results such as Canon CanoScan FS, Nikon CoolScan, Minolta multi Pro etc.., most of them being produced 20 years ago when the thing of scanning negatives was on everybody list which brings up the pesky issue of old drivers and new operating systems into full attention.

Both of these methods have one thing in common – it takes a very long time to scan. Each frame scanning and processing would be measured in minutes. Minute by minute and it can take easily few hours per roll of film. If you have many rolls to scan you will probably gave up pretty fast after you realize that you are going to be scanning for next few months.

Here I am describing a method that has been largely ignored, yet it is around 100 times faster and produces sharp results and resolution comparable to film scanners. Yes you can scan whole film in less than 2 minutes.

 

Enter the largely forgotten world of Macro Bellows

Having all on a single rails ensures that everything is is lined up, parallel and perfectly centered.

Macro bellows were commonly produced in the past for extreme close up photography by all major companies. (We are talking about 1970’s) Most of them would also offer some sort of film attachment for duplicating slide films and negatives.

Pictured on the left is a Vivitar bellows version with the copy atachement. Bellows are something like adjustable macro rings. By adding space between the lens and the camera we are able to focus much closer to the subject.

The best part is that you can find these dirt cheap (mostly because they need to be adapted to modern cameras and lenses before they can be actually used). In case of my Vivitar Bellows (which cost me whole $12 bucks with the film copy holder) that means adapting the camera and the lens to a T2 thread. This process may be actually easier with bellows made by a single maker for their system such as Nikon which would then use Nikon mount with Nikon lenses.

Adapting camera to the bellows is easy – there are many adapter rings that allows attaching this-or-that lens mount to any modern camera system. I am using Fuji X-T1 and of course there is FX to T2 adapter available. (In my case I 3d printed the adapter while waiting for the proper metal version to be shipped to me)

A little more challenging is to adapt a lens to the bellows. This requires an adapter from “whatever lens” to “whatever mount” your bellows has. If this was a Nikon that would be easy as you would use Nikon lens and that’s it. My Vivitar bellows has T2 mount on both sides which means I need to find the correct mount from whatever-lens to T2.

As for the lenses, for 35mm frame you want to use a prime lens that is about 50mm – 60mm, best if it is macro capable. There is also a trick which can be used with most other lenses – reversing them (yes you put the filter end towards the camera). This adds a bit of complexity in the adapter department and I won’t even go there. Fortunately there is a whole market for old used manual 50mm lenses.
I opted for pentax mount. Old manual pentax lenses are plentiful, inexpensive and great quality. (I paid for the one on the left about $10 in a thrift store)

Aperture ring on the manual lens is another thing that is common with old lenses and it is necessary because otherwise you have no other way to set aperture and you don’t want to use it wide open on fast lenses.

In my case the challenge is to mount PK lens to a T2 bellows. Such adapters were produced in the past so an old camera exchange store would be the best bet. In my case I made the adapter by myself (first I 3D printed one which was reasonable, then I actually disassembled some T2/Minolta ring and combined it with a mount from old pentax camera, some precise drilling and some very tiny screws and produced a super sturdy metal version of the adapter)

In my “production” version I ended up using a little beaten up Super Macro 50mm f4 Takumar lens that I found in the local ads for peanuts. It even included M42 to PK adapter so I could just swap the pentax lenses without making new adapter ring.
The advantage of using macro lens is that you can use the lens itself to fine focus to the film plate as it offers long focusing variability. With non-macro lens you would use the bellows itself to focus since the focusing of non-macro lens would make very little difference.

The last part is a light source behind the copy atachement which shouldn’t be a problem these days with plenty of LED photo lights. In my case the F4 of the lens was a good aperture that evens out any of old film curvature. I could set ISO 200 and shoot with about 1/30 to 1/60 shutter. The focus peaking on X-T1 makes precise focus very easy.

So what is the final word? The above contraption offers an incredible speed. “Scanning” entire roll of film is under 2 minutes – just basically how long it takes to advance the frame and press shutter button. As for quality it easily beats scanning on flat bed scanner – both for resolution and the sharpness. And I say it can easily match dedicated film scanners.

In the next part we will create a process in Photo Reactor to quickly turn the negative images into properly adjusted and toned positive images.

PSD Compatible Mode in Layers, what is it?

by

Originally when I build layers for version 5 some of the blending effects in DAP layers got (let’s call it by a mistake) reversed from how they behave in Photoshop. I simply didn’t compare what the same effects in Photoshop does. This wasn’t big deal when you use it all in DAP, until now when I added PSD export and realized that some things don’t looks correct in Photoshop. It affected only 5 non-symmetrical color modes where the order of layer matters most.

It is too late to change now so a new mode was added: PSD compatible mode that is ON by default on any new Layers in version 6 but off when you load presets.

That means if PSD Compatible Mode is OFF (then it works just as in version 5) and what you see on the screen may not appear the same way exported (Save PSD) in Photoshop if certain blending modes are used. The affected blending modes are mainly: ColorDodge, ColorBurn, VividLight, LinearLight and Pin Light.

To better illustrate the issue, we use “Reasure” layer preset from version 5. This preset uses Painted Image on the top and blend it with Input image below it using Pin Light mode to get subtle color effect from the input image. All is fine, until we export it to PSD as it will appear rather very different in Photoshop. Instead of input image lightly affecting the painted image it is the other way around, the painted image lightly affect the input image.

Now you see it is all wrong. The layers are in the same order, the modes are the same – but it looks different.
When you set the PSD Compatible Mode in version 6 to ON, DAP will mimic the Photoshop style blending and the image in DAP will then appear the same as in Photoshop when you export them:

Fixed?… Well not entirely.

The DAP layers and PSD exported layers have now the same look which is cool but sadly it isn’t actually the effect we originally wanted – it is reversed. In order to change version 5 preset into PSD Compatible version 6 you need to set PSD Compatible Mode and also swap the two affected layers – the Blending layer and the layer below it. However just swapping them is not enough, you also need to switch their blending modes (so the Input Image will be now on top and have Pin Light mode set and the Painted Image will be below it with Normal Blending)

The presets are still in v.5 mode so when you load preset the checkbox will be set to off. At some point I should change the presets also to PSD compatible mode.

U-Paint Helper

by

Quite a lot of people are using DAP as a preparation tool for real paintings. And I am not exception and used DAP occasionally to simply “pre-chew” a boring photo into something paint worthy.
The idea of U-Paint is that it breaks image into various steps and layers that can be helpful for real-world painting. For example I often want to see the values (something called zones in photography) which is a stepped grayscale version.

U-Paint is driven entirely by reactor and it creates a series of images that you can then export and use for painting (we are talking about real painting here). You can have it display in various ways as a step by step cumulative display where next step will just add on top of previous steps, as a mask previous step – where stuff that had been already painted will be masked out with a color, or as transparent stackable layers.
This of course all depends on the reactor file to return the correct images – which are basically like the last option – a series of transparent stackable overlays.

There are few reactor preset supplied and I am planning on making more. For example we can look at the Mono Wash which is probably the most obvious. Imagine you use single thin watercolor paint and then paint first very light layer of a light shades, let it dry, paint next layer of darker shades on top etc…

And Indeed I actually painted this way more than once. There are other Reactor presets that try to break down a color image into groups of colors by either hue or simply start painting in blocks and then refine the blocks further with smaller details.

If you have Reactor installed you can look at the insides. but be warned – it is messy. You also need to have Reactor 1.8 or newer.

So how do you create your own U-Paint Helper VFBOX file?

Each step is in general a transparent “overlay” that when stacked will produce the final image. (May not be always true)

But it doesn’t mean it had to be that way. You can have steps anything you want – they don’t need to stack or combine into a picture. The final reactor flow is then saved as vfbox file and put into the User Documents\DAP\upaint folder. (When you are editing directly from the DAP interface, this will be all done for you)

Each step is generated by attaching Write File Block where appropriate. The Write Block needs to have Name: “step” and also set “Add Number” which will then became the step number (make sure you don’t have gaps in numbering).

Note: In the new reactor you may find few interesting things if you have Photo-Reactor 1.8.1 and newer like the image below.

The first thing is there are straight lines with a number.  This is called “Beams” and it simply connect an object to the same node number somewhere else with a thin straight lines without making all the wormy connecting lines. Sort of like a portal. Right click on the object, select Line Draw and there it is.

Second thing is the sliders are blue and have an “A” to them. This is called a “Group Link” and it means when you move one slider, all of them having the same “letter” will move as well. This translates to the VFBOX parameters as well. And that is the third thing -an object which has any of its settings present in the Parameters (parameters that will be visible in VFBOX) has a small red dot. Well if any of the linked parameter of object (such as our “mult”) has a slider attached to the parameter and that slider is set in a group link, moving the parameter in VFBOX file (for example inside DAP) will ultimately change all the other linked sliders and parameters (in our case – all the “mult” objects).

To change the group link – click on the slider and look in the right hand properties – there should be a combo box where you can set the group “letter”. This works for slider and a knob.

Frequency separation with Photo-Reactor

by
Level: Intermediate

You may have already heard about Frequency Separation technique in photo editing, since it became popular in the past few years.

In short you separate your image into two parts: High Frequency that contains the texture and fine details and the Low Frequency that contain colors and tones and rough details.

This way you can focus your editing on just the texture or the tone and not being concerned with both at the same time.
Sounds pretty cool. So how to do it in Photo-Reactor?

The low frequency is generally just a blurred image with Gaussian blur. That part is easy.

But how do we get the High frequency component?
We don’t need to re-invent the wheel. The High frequency is the rest what was removed by blurring! Or to formulate it another way: it is the difference between the original and the blurred (low frequency) image and this is pretty much how Photoshop (or Photo-Reactor) High pass filter works.

We could do that with the reactor objects alone, but to keep things short and fast, we will use just a single reactor C++ block and type a short code that will do that part for us.

Remember the reactor c++ script needs also the first comment lines (the //## ) that will setup the number of inputs and variables for the block. Once you copy the code and press compile, the block will have two inputs and a slider.

 

//A sample Reactor Script - create High Pass
//##NAME:Create High Pass form original and blurred image
//##DESCRIPTION:first node is the original image, second node is blurred
//##INPUTS:2
//##VAR1:50
//##VAR1_NAME:Multiplier


void main()
{
	// get the image from input socket
	fimage img1(INPUT1);
	fimage img2(INPUT2);

  	int width = img1.width;
	int height = img1.height;


   float r,g,b;

   float multip = VAR1/100.0;

   for (int y=0; y<height; y++)
   {
      for (int x=0; x<width; x++)
      {

         // one way to get color from pixel
         fpixel color1 = img1.Pixel(x,y);
         fpixel color2 = img2.Pixel(x,y);

         r = color1.r-color2.r;
         g = color1.g-color2.g;
			b = color1.b-color2.b;

			r = r*multip+0.5;
			g = g*multip+0.5;
			b = b*multip+0.5;
         img1.SetRGB(x, y, r, g, b);

      }
   
   }
	
	
	// send the image to output
	img1.SetOutput();
	
}

If you do this right, the output will show High pass image and when you change the Blur radius, it will work exactly like the radius in High Pass filter in Photoshop.

We added one variable “Multiplier” to the object. By default it should be in the middle (50) and that would produce the High Frequency as the exact counterpart to the Blur (Low Frequency). We can use this slider later for experimenting to add or remove the High Frequency.

How to tie all this together?
The output from the Blur block is the Low Frequency, the output of the C++ block is the High Frequency. So how do we merge them together back. Luckily there is Linear Light blend mode, that will do all that for us.

In this configuration as on the picture the Linear Light blend object need to have Swap layers to apply it correctly, or you can just wire the Blur to A and C++ to B.

If everything is right, then the output should be now the same as input. If it isn’t check if you have Swap Layers set on the Linear Light.

So after all this we produced exactly nothing as the output looks the same as the input. But that is the proof that it works we needed! We separated the image into two frequencies and then merge them together.

The Blur Radius determines the Split point between the frequencies and we can drop a Log Knob on the Blur object to extract that value to the workplace for easy manipulation.
Having a single split point is also the reason why we didn’t just use the build-in High Pass filter that exist already in Photo-Reactor. We really want the High frequency leg to be the exact counterpart of the low frequency. Regardless where we put the split point (Blur radius) the result image will be still same as the input even though both low and high pictures will change dramatically.

 

So it is now entirely up to you how to use it. I dropped few pins so I can easily connect objects in the path between them.

For example I can add Median or Noise reduction to the High Pass path and Saturation to the Low pass… but it can be as complex or as experimental as you want.

There are many uses, for example we can soften skin on portraits without changing the tone. Or we can do crazy things. But I leave it for you now.

If you want to download a ready made flow, get this image (right click, Save Link As) and then just drag it to Photo Reactor from Windows explorer.
When it asks you if you want to load it as image or Load as flow, say flow. Then it will ask you to save the currently opened project before it opens the project from embedded image. You can just press Cancel at that point if you didn’t work at anything else.

Tools used in this article

Photo-Reactor features used in this article:

  • Self-Documenting Flow
  • Gaussian Blur object
  • Script Object with c++ language
  • Blend Object
  • Knob Object
  • Pin Objects