boofcv.factory.distort.FactoryDistort Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of boofcv-ip Show documentation
BoofCV is an open source Java library for real-time computer vision and robotics applications.
There is a newer version: 1.1.6
/*
 * Copyright (c) 2011-2019, Peter Abeles. All Rights Reserved.
 *
 * This file is part of BoofCV (http://boofcv.org).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package boofcv.factory.distort;

import boofcv.abst.distort.ConfigDeformPointMLS;
import boofcv.abst.distort.PointDeformKeyPoints;
import boofcv.abst.distort.PointDeform_MLS;
import boofcv.alg.distort.*;
import boofcv.alg.distort.impl.ImplImageDistort_PL;
import boofcv.alg.distort.mls.ImageDeformPointMLS_F32;
import boofcv.alg.interpolate.InterpolatePixel;
import boofcv.alg.interpolate.InterpolatePixelMB;
import boofcv.alg.interpolate.InterpolatePixelS;
import boofcv.alg.interpolate.InterpolationType;
import boofcv.concurrency.BoofConcurrency;
import boofcv.factory.interpolate.FactoryInterpolation;
import boofcv.struct.border.BorderType;
import boofcv.struct.image.*;

/**
 * @author Peter Abeles
 */
public class FactoryDistort {

	/**
	 * Creates a {@link boofcv.alg.distort.ImageDistort} for the specified image type, transformation
	 * and interpolation instance.  Min and max pixel values are assumed to be 0 and 255, respectively.
	 *
	 * @param cached If true the distortion is only computed one.  False for recomputed each time, but less memory.
	 * @param interpolationType  Which interpolation method it should use
	 * @param borderType How pixels outside the image border are handled
	 * @param inputType Type of input image
	 * @param outputType Type of output image
	 * @return ImageDistort
	 */
	public static , Output extends ImageBase>
	ImageDistort distort(boolean cached, InterpolationType interpolationType, BorderType borderType,
										ImageType inputType, ImageType outputType) {
		InterpolatePixel interp =
				FactoryInterpolation.createPixel(0,255, interpolationType,borderType,inputType);

		return distort(cached, interp,outputType);
	}

	/**
	 * Creates a {@link boofcv.alg.distort.ImageDistort} for the specified image type, transformation
	 * and interpolation instance.
	 *
	 * @param cached If true the distortion is only computed one.  False for recomputed each time, but less memory.
	 * @param interp Which interpolation algorithm should be used.
	 * @param outputType Type of output image.
	 * @return ImageDistort
	 */
	public static , Output extends ImageBase>
	ImageDistort distort(boolean cached, InterpolatePixel interp, ImageType outputType) {
		switch( outputType.getFamily() ) {
			case GRAY:
				return distortSB(cached,(InterpolatePixelS)interp,outputType.getImageClass());
			case PLANAR:
				return distortPL(cached,(InterpolatePixelS)interp,outputType.getImageClass());
			case INTERLEAVED:
				if( interp instanceof InterpolatePixelS )
					throw new IllegalArgumentException("Interpolation function for single band images was" +
							" passed in for an interleaved image");
				return distortIL(cached,(InterpolatePixelMB) interp, (ImageType)outputType);
			default:
				throw new IllegalArgumentException("Unknown image family "+outputType.getFamily());
		}
	}

	/**
	 * Creates a {@link boofcv.alg.distort.ImageDistort} for the specified image type, transformation
	 * and interpolation instance.
	 *
	 * @param cached If true the distortion is only computed one.  False for recomputed each time, but less memory.
	 * @param interp Which interpolation algorithm should be used.
	 * @param outputType Type of output image.
	 */
	public static , Output extends ImageGray>
	ImageDistort distortSB(boolean cached, InterpolatePixelS interp, Class outputType)
	{
		AssignPixelValue_SB assigner;
		if( outputType == GrayF32.class ) {
			assigner = (AssignPixelValue_SB)new AssignPixelValue_SB.F32();
		} else if( GrayS32.class.isAssignableFrom(outputType) ) {
			assigner = (AssignPixelValue_SB)new AssignPixelValue_SB.S32();
		} else if( GrayI16.class.isAssignableFrom(outputType) ) {
			assigner = (AssignPixelValue_SB)new AssignPixelValue_SB.I16();
		} else if( GrayI8.class.isAssignableFrom(outputType) ) {
			assigner = (AssignPixelValue_SB)new AssignPixelValue_SB.I8();
		} else {
			throw new IllegalArgumentException("Output type not supported: "+outputType.getSimpleName());
		}

		if(BoofConcurrency.USE_CONCURRENT ) {
			if( cached ) {
				return new ImageDistortCache_SB_MT<>(assigner,interp);
			} else {
				return new ImageDistortBasic_SB_MT<>(assigner,interp);
			}
		} else if( cached ) {
			return new ImageDistortCache_SB<>(assigner,interp);
		} else {
			return new ImageDistortBasic_SB<>(assigner,interp);
		}
	}

	/**
	 * Creates a {@link boofcv.alg.distort.ImageDistort} for the planar images, transformation
	 * and interpolation instance.
	 *
	 * @param cached If true the distortion is only computed one.  False for recomputed each time, but less memory.
	 * @param interp Which interpolation algorithm should be used.
	 * @param outputType Type of output image.
	 */
	public static ,Output extends ImageGray>
	ImageDistort,Planar>
	distortPL(boolean cached , InterpolatePixelS interp, Class outputType)
	{
		ImageDistort distortSingle = distortSB(cached, interp, outputType);
		return new ImplImageDistort_PL<>(distortSingle);
	}

	public static , Output extends ImageInterleaved>
	ImageDistort
	distortIL(boolean cached, InterpolatePixelMB interp, ImageType outputType)
	{
		if( cached ) {
			throw new IllegalArgumentException("Cached not supported yet");
		} else {
			AssignPixelValue_MB assigner;
			switch( outputType.getDataType() ) {
				case F32: assigner = (AssignPixelValue_MB)new AssignPixelValue_MB.F32(); break;
				case S32: assigner = (AssignPixelValue_MB)new AssignPixelValue_MB.S32(); break;
				case U16:
				case S16:
				case I16: assigner = (AssignPixelValue_MB)new AssignPixelValue_MB.I16(); break;
				case U8:
				case S8:
				case I8: assigner = (AssignPixelValue_MB)new AssignPixelValue_MB.I8(); break;
				default:
					throw new RuntimeException("Not yet supported "+outputType);
			}

			if(BoofConcurrency.USE_CONCURRENT ) {
				return new ImageDistortBasic_IL_MT<>(assigner,interp);
			} else {
				return new ImageDistortBasic_IL<>(assigner,interp);
			}
		}
	}

	public static PointDeformKeyPoints deformMls(ConfigDeformPointMLS config ) {
		if( config == null )
			config = new ConfigDeformPointMLS();

		ImageDeformPointMLS_F32 alg = new ImageDeformPointMLS_F32(config.type);
		alg.setAlpha(config.alpha);

		return new PointDeform_MLS(alg, config.rows, config.cols);
	}
}