Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Copyright (c) 2020, 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.core.image;
import boofcv.struct.border.ImageBorder;
import boofcv.struct.border.ImageBorder_F32;
import boofcv.struct.border.ImageBorder_F64;
import boofcv.struct.border.ImageBorder_S32;
import boofcv.struct.image.*;
/**
* Factory for creating generalized images
*
* @author Peter Abeles
*/
@SuppressWarnings("rawtypes")
public class FactoryGImageGray {
public static GImageGray create( Class imageType ) {
if (imageType == GrayU8.class)
return new GSingle_U8(null);
else if (imageType == GrayS8.class)
return new GSingle_S8(null);
else if (imageType == GrayU16.class)
return new GSingle_U16(null);
else if (imageType == GrayS16.class)
return new GSingle_S16(null);
else if (imageType == GrayS32.class)
return new GSingle_S32(null);
else if (imageType == GrayS64.class)
return new GSingle_I64(null);
else if (imageType == GrayF32.class)
return new GSingle_F32(null);
else if (imageType == GrayF64.class)
return new GSingle_F64(null);
else
throw new IllegalArgumentException("Unknown image type: " + imageType);
}
public static GImageGray wrap( ImageGray image ) {
if (image.getClass() == GrayU8.class)
return new GSingle_U8((GrayU8)image);
else if (image.getClass() == GrayS8.class)
return new GSingle_S8((GrayS8)image);
else if (image.getClass() == GrayU16.class)
return new GSingle_U16((GrayU16)image);
else if (image.getClass() == GrayS16.class)
return new GSingle_S16((GrayS16)image);
else if (image.getClass() == GrayS32.class)
return new GSingle_S32((GrayS32)image);
else if (image.getClass() == GrayS64.class)
return new GSingle_I64((GrayS64)image);
else if (image.getClass() == GrayF32.class)
return new GSingle_F32((GrayF32)image);
else if (image.getClass() == GrayF64.class)
return new GSingle_F64((GrayF64)image);
else
throw new IllegalArgumentException("Unknown image type: " + image.getClass());
}
public static GImageGray wrap( ImageGray image, GImageGray output ) {
if (output == null)
return wrap(image);
if (image.getClass() == GrayU8.class)
((GSingle_U8)output).image = (GrayU8)image;
else if (image.getClass() == GrayS8.class)
((GSingle_S8)output).image = (GrayS8)image;
else if (image.getClass() == GrayU16.class)
((GSingle_U16)output).image = (GrayU16)image;
else if (image.getClass() == GrayS16.class)
((GSingle_S16)output).image = (GrayS16)image;
else if (image.getClass() == GrayS32.class)
((GSingle_S32)output).image = (GrayS32)image;
else if (image.getClass() == GrayS64.class)
((GSingle_I64)output).image = (GrayS64)image;
else if (image.getClass() == GrayF32.class)
((GSingle_F32)output).image = (GrayF32)image;
else if (image.getClass() == GrayF64.class)
((GSingle_F64)output).image = (GrayF64)image;
else
throw new IllegalArgumentException("Unknown image type: " + image.getClass());
return output;
}
public static GImageGray wrap( ImageBorder image ) {
if (GrayI.class.isAssignableFrom(image.getImage().getClass()))
return new Border_S32((ImageBorder_S32)image);
else if (image.getImage().getClass() == GrayF32.class)
return new Border_F32((ImageBorder_F32)image);
else if (image.getImage().getClass() == GrayF64.class)
return new Border_F64((ImageBorder_F64)image);
else
throw new IllegalArgumentException("Unknown image type: " + image.getClass());
}
public static class Border_S32 extends GSingleBorder {
public Border_S32( ImageBorder_S32 image ) {
super(image);
}
@Override
public boolean isFloatingPoint() {
return false;
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public double unsafe_getD( int x, int y ) {
return image.get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.get(x, y);
}
@Override
public void set( int index, float value ) {
throw new RuntimeException("Operation not supported by inner data type");
}
@Override
public float getF( int index ) {
throw new RuntimeException("Operation not supported by inner data type");
}
@Override
public Class getImageType() {
return getImage().getImageType().getImageClass();
}
}
public static class Border_F32 extends GSingleBorder {
public Border_F32( ImageBorder_F32 image ) {
super(image);
}
@Override
public boolean isFloatingPoint() {
return true;
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.floatValue());
}
@Override
public void set( int index, float value ) {
throw new RuntimeException("Operation not supported by inner data type");
}
@Override
public float getF( int index ) {
throw new RuntimeException("Operation not supported by inner data type");
}
@Override
public Class getImageType() {
return GrayF32.class;
}
}
public static class Border_F64 extends GSingleBorder {
public Border_F64( ImageBorder_F64 image ) {
super(image);
}
@Override
public boolean isFloatingPoint() {
return true;
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return (float)image.get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.floatValue());
}
@Override
public void set( int index, float value ) {
throw new RuntimeException("Operation not supported by inner data type");
}
@Override
public float getF( int index ) {
throw new RuntimeException("Operation not supported by inner data type");
}
@Override
public Class getImageType() {
return GrayF64.class;
}
}
public static class GSingle_U8 extends GSingleBaseInt {
public GSingle_U8( GrayU8 image ) {
super(image);
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public void set( int index, float value ) {
image.data[index] = (byte)value;
}
@Override
public float getF( int index ) {
return image.data[index] & 0xFF;
}
@Override
public Class getImageType() {
return GrayU8.class;
}
}
public static class GSingle_S8 extends GSingleBaseInt {
public GSingle_S8( GrayS8 image ) {
super(image);
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = (byte)value;
}
@Override
public float getF( int index ) {
return image.data[index];
}
@Override
public Class getImageType() {
return GrayS8.class;
}
}
public static class GSingle_U16 extends GSingleBaseInt {
public GSingle_U16( GrayU16 image ) {
super(image);
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = (short)value;
}
@Override
public float getF( int index ) {
return image.data[index] & 0xFFFF;
}
@Override
public Class getImageType() {
return GrayU16.class;
}
}
public static class GSingle_S16 extends GSingleBaseInt {
public GSingle_S16( GrayS16 image ) {
super(image);
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = (short)value;
}
@Override
public float getF( int index ) {
return image.data[index];
}
@Override
public Class getImageType() {
return GrayS16.class;
}
}
public static class GSingle_S32 extends GSingleBaseInt {
public GSingle_S32( GrayS32 image ) {
super(image);
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = (short)value;
}
@Override
public float getF( int index ) {
return image.data[index];
}
@Override
public Class getImageType() {
return GrayS32.class;
}
}
public static class GSingle_I64 extends GSingleBaseInt {
public GSingle_I64( GrayS64 image ) {
super(image);
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.intValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = (long)value;
}
@Override
public float getF( int index ) {
return image.data[index];
}
@Override
public Class getImageType() {
return GrayS64.class;
}
}
public static class GSingle_F32 extends GSingleBase {
public GSingle_F32( GrayF32 image ) {
super(image);
}
@Override
public boolean isFloatingPoint() {
return true;
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.unsafe_get(x, y);
}
@Override
public float unsafe_getF( int x, int y ) {
return image.data[image.getIndex(x, y)];
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.floatValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = value;
}
@Override
public float getF( int index ) {
return image.data[index];
}
@Override
public Class getImageType() {
return GrayF32.class;
}
}
public static class GSingle_F64 extends GSingleBase {
public GSingle_F64( GrayF64 image ) {
super(image);
}
@Override
public boolean isFloatingPoint() {
return true;
}
@Override
public Number get( int x, int y ) {
return image.get(x, y);
}
@Override
public double unsafe_getD( int x, int y ) {
return image.data[image.getIndex(x, y)];
}
@Override
public float unsafe_getF( int x, int y ) {
return (float)image.unsafe_get(x, y);
}
@Override
public void set( int x, int y, Number num ) {
image.set(x, y, num.doubleValue());
}
@Override
public void set( int index, float value ) {
image.data[index] = value;
}
@Override
public float getF( int index ) {
return (float)image.data[index];
}
@Override
public Class getImageType() {
return GrayF64.class;
}
}
public static abstract class GSingleBaseInt> extends GSingleBase {
protected GSingleBaseInt( T image ) {
super(image);
}
@Override
public boolean isFloatingPoint() {
return false;
}
}
public static abstract class GSingleBase> implements GImageGray {
protected T image;
protected GSingleBase( T image ) {
this.image = image;
}
@Override
public void wrap( ImageGray image ) {
this.image = (T)image;
}
@Override
public int getWidth() {
return image.getWidth();
}
@Override
public int getHeight() {
return image.getHeight();
}
@Override
public ImageGray getImage() {
return image;
}
}
public static abstract class GSingleBorder implements GImageGray {
protected T image;
protected GSingleBorder( T image ) {
this.image = image;
}
@Override
public void wrap( ImageGray image ) {
this.image.setImage(image);
}
@Override
public int getWidth() {
return image.getImage().getWidth();
}
@Override
public int getHeight() {
return image.getImage().getHeight();
}
@Override
public ImageGray getImage() {
return (ImageGray)image.getImage();
}
}
}
