clear();
##definitions##
string filtertype$;
string sourcetype$;
string targettype$;
string sourcefilepath$;
string sourcefilepath2$;
string sourcefilepath3$;
string sourceobjectpath$;
string sourceobjectpath2$;
string sourceobjectpath3$;
string sourceobjectpath4$;
string sourceobjectpath5$;
string correctfilepath$;
string correctobjectpath$;
class FILEPATH sourcefile = sourcefilepath$;
class FILEPATH sourcefile2 = sourcefilepath2$;
class FILEPATH sourcefile3 = sourcefilepath3$;
class RVC_OBJITEM sourceobjitem;
sourceobjitem.SetFilePath(sourcefilepath$);
sourceobjitem.SetObjectPath(sourceobjectpath$);
class RVC_OBJITEM sourceobjitem2;
sourceobjitem2.SetFilePath(sourcefilepath$);
sourceobjitem2.SetObjectPath(sourceobjectpath2$);
class RVC_OBJITEM sourceobjitem3;
sourceobjitem3.SetFilePath(sourcefilepath$);
sourceobjitem3.SetObjectPath(sourceobjectpath3$);
class RVC_OBJITEM sourceobjitem4;
sourceobjitem4.SetFilePath(sourcefilepath$);
sourceobjitem4.SetObjectPath(sourceobjectpath4$);
class RVC_OBJITEM sourceobjitem5;
sourceobjitem5.SetFilePath(sourcefilepath$);
sourceobjitem5.SetObjectPath(sourceobjectpath5$);
string outfilepath$ = CreateTempFileName();
string rvcfilepath$ = CreateTempFileName();
class FILEPATH outfile = outfilepath$;
class FILEPATH correctfile = correctfilepath$;
class RVC_OBJITEM outobjitem;
CreateProjectFile(rvcfilepath$, "Filter Tests");
outobjitem.SetFilePath(rvcfilepath$);
outobjitem.SetObjectPath(correctobjectpath$);
class RVC_DESCRIPTOR desc;
desc.SetName(correctobjectpath$);
desc.SetDescription("Filter Tests");
outobjitem.CreateNew(desc, "RASTER");
####
class RVC_RASTER RDest;
numeric err = 0;
proc ReportError(numeric linenum, numeric err) {
print ("FAILED - line: ", linenum, " , error: ", err);
Exit();
}
### SOURCE ###
class IMAGE_PIPELINE_SOURCE source;
class IMAGE_PIPELINE_SOURCE source2;
class IMAGE_PIPELINE_SOURCE source3;
class IMAGE_PIPELINE_SOURCE source4;
class IMAGE_PIPELINE_SOURCE source5;
switch(sourcetype$) {
case "JPEG":
class IMAGE_PIPELINE_SOURCE_JPEG source_jpeg(sourcefile);
source = source_jpeg;
class IMAGE_PIPELINE_SOURCE_JPEG source_jpeg2(sourcefile2);
source2 = source_jpeg2;
class IMAGE_PIPELINE_SOURCE_JPEG source_jpeg3(sourcefile3);
source3 = source_jpeg3;
break;
case "PNG":
class IMAGE_PIPELINE_SOURCE_PNG source_png(sourcefile);
source = source_png;
class IMAGE_PIPELINE_SOURCE_PNG source_png2(sourcefile2);
source2 = source_png2;
class IMAGE_PIPELINE_SOURCE_PNG source_png3(sourcefile3);
source3 = source_png3;
break;
case "WBMP":
class IMAGE_PIPELINE_SOURCE_WBMP source_wbmp(sourcefile);
source = source_wbmp;
class IMAGE_PIPELINE_SOURCE_WBMP source_wbmp2(sourcefile2);
source2 = source_wbmp2;
class IMAGE_PIPELINE_SOURCE_WBMP source_wbmp3(sourcefile3);
source3 = source_wbmp3;
break;
case "RVC":
class IMAGE_PIPELINE_SOURCE_RVC source_rvc(sourceobjitem);
source = source_rvc;
class IMAGE_PIPELINE_SOURCE_RVC source_rvc2(sourceobjitem2);
source2 = source_rvc2;
class IMAGE_PIPELINE_SOURCE_RVC source_rvc3(sourceobjitem3);
source3 = source_rvc3;
class IMAGE_PIPELINE_SOURCE_RVC source_rvc4(sourceobjitem4);
source4 = source_rvc4;
class IMAGE_PIPELINE_SOURCE_RVC source_rvc5(sourceobjitem5);
source5 = source_rvc5;
break;
default:
Exit();
break;
}
err = source.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
###########
### FILTER ###
class IMAGE_PIPELINE_FILTER filter;
switch(filtertype$) {
case "FILTER_CACHEIMAGE":
{
# define by xml control
numeric MemoryMaxUsage;
numeric TileRows;
numeric TileColumns;
#
class IMAGE_PIPELINE_FILTER_CACHEIMAGE filter_cacheimage(source, MemoryMaxUsage, TileRows, TileColumns);
filter = filter_cacheimage;
}
break;
case "FILTER_COLORBALANCE":
{
# define by xml control
numeric Contrast;
numeric Intensity;
numeric Saturation;
#
class CBPARMS cbparms;
cbparms.con_val = Contrast;
cbparms.int_val = Intensity;
cbparms.sat_val = Saturation;
class IMAGE_PIPELINE_FILTER_COLORBALANCE filter_colorbalance(source, cbparms);
filter = filter_colorbalance;
}
break;
case "FILTER_COMPOSITE":
{
# define by xml control
string PixelType$; #invalid to determine automatically
#
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = source3.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_STAGE_ARRAY stages(source, source2, source3);
class IMAGE_PIPELINE_FILTER_COMPOSITE filter_composite(stages, PixelType$);
filter = filter_composite;
}
break;
case "FILTER_CROP":
{
# define by xml control
numeric cropx1, cropx2, cropy1, cropy2;
#
class RECT croprect;
croprect.Set(cropx1, cropy1, cropx2, cropy2);
class IMAGE_PIPELINE_FILTER_CROP filter_crop(source, croprect);
filter = filter_crop;
}
break;
case "FILTER_DATATYPE":
{
# define by xml control
string DataType;
string Mode;
numeric MinValue;
numeric MaxValue;
#
class IMAGE_PIPELINE_FILTER_DATATYPE filter_datatype;
if (MinValue == 0 && MaxValue == 0)
filter_datatype = new IMAGE_PIPELINE_FILTER_DATATYPE(source, DataType, Mode);
else
filter_datatype = new IMAGE_PIPELINE_FILTER_DATATYPE(source, DataType, Mode, MinValue, MaxValue);
filter = filter_datatype;
}
break;
case "FILTER_DEINDEX":
{
class IMAGE_PIPELINE_FILTER_DEINDEX filter_deindex(source);
filter = filter_deindex;
}
break;
case "FILTER_EXTEND":
{
#define by xml control
numeric NumColumnsAdd;
numeric NumRowsAdd;
#
class IMAGE_PIPELINE_FILTER_EXTEND filter_extend(source, NumColumnsAdd, NumRowsAdd, source.GetTotalColumns() + NumColumnsAdd, source.GetTotalRows() + NumRowsAdd);
filter = filter_extend;
}
break;
case "FILTER_FOCALTOPOGRAPHIC":
{
# define by xml control
numeric DoAspect;
string AspectDataType$;
numeric DoProfile;
numeric DoPlan;
string CurvatureDataType$;
string CurvatureUnits$;
numeric DoShading;
string ShadingDataType$;
string ShadingMethod$;
numeric DoSlope;
string SlopeDataType$;
string SlopeUnits$;
string SurfaceFittingMethod$;
numeric DirectionOfSun;
numeric ElevationAngleOfSun;
numeric ElevationScale;
numeric XCellSize;
numeric YCellSize;
#
class IMAGE_PIPELINE_FILTER_FOCALTOPOGRAPHIC_SETTINGS toposettings;
toposettings.SetAspectParms(DoAspect, AspectDataType$);
toposettings.SetCurvatureParms(DoProfile, DoPlan, CurvatureDataType$, CurvatureUnits$);
toposettings.SetShadingParms(DoShading, ShadingDataType$, ShadingMethod$);
toposettings.SetSlopeParms(DoSlope, SlopeDataType$, SlopeUnits$);
toposettings.SetSurfaceFittingMethod(SurfaceFittingMethod$);
toposettings.SetDirectionOfSun(DirectionOfSun);
toposettings.SetElevationAngleOfSun(ElevationAngleOfSun);
toposettings.SetElevationScale(ElevationScale);
toposettings.SetXCellSize(XCellSize);
toposettings.SetYCellSIze(YCellSize);
class IMAGE_PIPELINE_FILTER_FOCALTOPOGRAPHIC filter_focaltopographic(source, toposettings);
filter = filter_focaltopographic;
}
break;
case "FILTER_FUSION_BASICHBS":
{
# define by xml control
numeric MaxHighRes;
numeric MaxRGB;
#
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_FUSION_BASICHBS filter_fusion_basichbs(source, source2, MaxHighRes, MaxRGB);
filter = filter_fusion_basichbs;
}
break;
case "FILTER_FUSION_BASICHIS":
{
# define by xml control
numeric MaxHighRes;
numeric MaxRGB;
#
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_FUSION_BASICHIS filter_fusion_basichis(source, source2, MaxHighRes, MaxRGB);
filter = filter_fusion_basichis;
}
break;
case "FILTER_FUSION_BROVEY":
{
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_FUSION_BROVEY filter_fusion_brovey(source, source2);
filter = filter_fusion_brovey;
}
break;
case "FILTER_FUSION_MODHIS":
{
# define by xml control
numeric MaxHighRes;
numeric MaxRGB;
numeric Proportion;
numeric Boost;
numeric MaxSaturation;
numeric UseEffectiveColorIntensity;
#
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_FUSION_MODHIS filter_fusion_modhis(source, source2, MaxHighRes, MaxRGB);
filter_fusion_modhis.SetIntensityProportion(Proportion);
filter_fusion_modhis.SetSaturationBoost(Boost);
filter_fusion_modhis.SetSaturationMax(MaxSaturation);
filter_fusion_modhis.SetUseEffectiveColorIntensity(UseEffectiveColorIntensity);
filter = filter_fusion_modhis;
}
break;
case "FILTER_FUSION_TEXTUREPCA":
{
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_FUSION_TEXTUREPCA filter_fusion_texturepca(source, source2);
filter = filter_fusion_texturepca;
}
break;
case "FILTER_LINEAR":
{
#define by xml control
numeric Coefficient;
numeric Offset;
#
class IMAGE_PIPELINE_FILTER_LINEAR filter_linear(source);
numeric i = 0;
for i = 0 to source.GetNumSamples() {
filter_linear.SetCoefficient(i, i, Coefficient);
filter_linear.SetOffset(i, Offset);
}
filter = filter_linear;
if (targettype$ == "JPEG" || targettype$ == "J2K" || targettype$ == "PNG") {
err = filter_linear.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_DATATYPE filter_uint8(filter_linear, "UINT8", "Rescale", 0, 255);
filter = filter_uint8;
}
}
break;
case "FILTER_LOOKUP":
{
class IMAGE_PIPELINE_SAMPLETABLE sampletable;
class IMAGE_PIPELINE_SAMPLE sample("Gray", "UINT8");
sampletable.Create(sample, 255);
numeric i = 0;
for i = 0 to 254
sampletable.SetItem(i, 255-i);
class IMAGE_PIPELINE_FILTER_LOOKUP filter_lookup(source);
filter_lookup.SetSampleTable(0, sampletable, 0, 1);
filter = filter_lookup;
}
break;
case "FILTER_MASKVALIDITY":
{
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_FILTER_MASKVALIDITY filter_maskvalidity(source, source2);
filter = filter_maskvalidity;
}
break;
case "FILTER_MORPHOLOGY_CLOSING":
{
# define by xml control
numeric NumRows;
numeric NumColumns;
string Shape$;
numeric OnValue;
numeric OffValue;
string Rotation$;
#
class IMAGE_PIPELINE_FILTER_MORPHOLOGY_CLOSING filter_morphology_closing(source);
filter_morphology_closing.SetMatrix(NumRows, NumColumns, Shape$, OnValue, OffValue, Rotation$);
filter = filter_morphology_closing;
}
break;
case "FILTER_MORPHOLOGY_DILATION":
{
# define by xml control
numeric NumRows;
numeric NumColumns;
string Shape$;
numeric OnValue;
numeric OffValue;
string Rotation$;
#
class IMAGE_PIPELINE_FILTER_MORPHOLOGY_DILATION filter_morphology_dilation(source);
filter_morphology_dilation.SetMatrix(NumRows, NumColumns, Shape$, OnValue, OffValue, Rotation$);
filter = filter_morphology_dilation;
}
break;
case "FILTER_MORPHOLOGY_EROSION":
{
# define by xml control
numeric NumRows;
numeric NumColumns;
string Shape$;
numeric OnValue;
numeric OffValue;
string Rotation$;
#
class IMAGE_PIPELINE_FILTER_MORPHOLOGY_EROSION filter_morphology_erosion(source);
filter_morphology_erosion.SetMatrix(NumRows, NumColumns, Shape$, OnValue, OffValue, Rotation$);
filter = filter_morphology_erosion;
}
break;
case "FILTER_MORPHOLOGY_OPENING":
{
# define by xml control
numeric NumRows;
numeric NumColumns;
string Shape$;
numeric OnValue;
numeric OffValue;
string Rotation$;
#
class IMAGE_PIPELINE_FILTER_MORPHOLOGY_OPENING filter_morphology_opening(source);
filter_morphology_opening.SetMatrix(NumRows, NumColumns, Shape$, OnValue, OffValue, Rotation$);
filter = filter_morphology_opening;
}
break;
case "FILTER_MOSAIC":
{
# define by xml control
numeric TotalColumns;
numeric TotalRows;
string ResampleMethod$;
string OverlapMethod$;
string InputCRS$;
string OutputCRS$;
#
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = source3.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = source4.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = source5.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_STAGE_ARRAY stages(source2, source3, source4, source5);
#by dimensions and trans map gen:
#class IMAGE_PIPELINE_DIMENSIONS dimensions;
#dimensions.SetTotalDimensions(TotalColumns, TotalRows);
#class SR_COORDREFSYS inputcrs, outputcrs;
#inputcrs.Assign(InputCRS$);
#outputcrs.Assign(OutputCRS$);
#class TRANS2D_MAPGEN TransMapGen;
#TransMapGen.InputCoordRefSys = inputcrs;
#TransMapGen.OutputCoordRefSys = outputcrs;
#class IMAGE_PIPELINE_FILTER_MOSAIC filter_mosaic(stages, dimensions, TransMapGen, ResampleMethod$, OverlapMethod$);
#use reference image to mosaic
class IMAGE_PIPELINE_FILTER_MOSAIC filter_mosaic(stages, source, ResampleMethod$, OverlapMethod$);
filter = filter_mosaic;
}
break;
case "FILTER_MULTIPLY":
{
err = source2.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = source3.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_STAGE_ARRAY stages(source, source2, source3);
class IMAGE_PIPELINE_PIXEL pixel("Grayscale", "UINT8");
class IMAGE_PIPELINE_FILTER_MULTIPLY filter_multiply(stages, pixel);
filter = filter_multiply;
}
break;
case "FILTER_OVERRIDETYPE":
{
# define by xml control
string PixelType$;
#
class IMAGE_PIPELINE_FILTER_OVERRIDETYPE filter_overridetype(source, PixelType$);
filter = filter_overridetype;
}
break;
case "FILTER_PIXELTABLE":
{
class IMAGE_PIPELINE_PIXELTABLE table;
class IMAGE_PIPELINE_PIXEL pixelprop("Grayscale", "UINT8");
pixelprop.SetValueMaximum();
table.Create(pixelprop, 255);
table.SetAll(pixelprop);
class IMAGE_PIPELINE_FILTER_PIXELTABLE filter_pixeltable(source, table);
filter = filter_pixeltable;
}
break;
case "FILTER_PIXELTYPE":
{
# define by xml control
string TargetPixelType$;
numeric ColorMaxValue;
string TargetDataType$;
#
class IMAGE_PIPELINE_FILTER_PIXELTYPE filter_pixeltype(source, TargetPixelType$, ColorMaxValue, TargetDataType$);
filter = filter_pixeltype;
}
break;
case "FILTER_QUANTIZE":
{
class IMAGE_PIPELINE_SAMPLETABLE sampletable;
class IMAGE_PIPELINE_SAMPLE sample("Gray", "UINT8");
sampletable.Create(sample, 17);
sampletable.SetItem(0, 15);
sampletable.SetItem(1, 30);
sampletable.SetItem(2, 45);
sampletable.SetItem(3, 60);
sampletable.SetItem(4, 75);
sampletable.SetItem(5, 90);
sampletable.SetItem(6, 105);
sampletable.SetItem(7, 120);
sampletable.SetItem(8, 135);
sampletable.SetItem(9, 150);
sampletable.SetItem(10, 165);
sampletable.SetItem(11, 180);
sampletable.SetItem(12, 195);
sampletable.SetItem(13, 210);
sampletable.SetItem(14, 225);
sampletable.SetItem(15, 240);
sampletable.SetItem(16, 255);
class IMAGE_PIPELINE_FILTER_QUANTIZE filter_quantize(source);
filter_quantize.SetSampleTable(0, sampletable);
filter = filter_quantize;
}
break;
case "FILTER_REPLACENULL":
{
# define by xml control
numeric ValueReplace;
#
class IMAGE_PIPELINE_FILTER_REPLACENULL filter_replacenull(source, ValueReplace);
filter = filter_replacenull;
}
break;
case "FILTER_RESAMPLE":
{
# Get the Source raster and Target raster locations
class RVC_RASTER SrcRastObj;
err = SrcRastObj.Open(sourceobjitem);
if (err < 0) ReportError(_context.CurrentLineNum, err);
# Get the extents of the Source raster in Map coordinates
class RVC_GEOREFERENCE SrcGeorefObj;
err = SrcRastObj.GetDefaultGeoref(SrcGeorefObj);
if (err < 0) { print("Error:", err, " On Line:", _context.CurrentLineNum); Exit(); }
err = SrcGeorefObj.OpenAttached();
if (err < 0) { print("Error:", err, " On Line:", _context.CurrentLineNum); Exit(); }
class TRANSMODEL TransModel;
TransModel.SetType("None");
class TRANS2D_MAPGEN TransSrcObjToMap;
err = SrcGeorefObj.GetTransParm(TransSrcObjToMap, 0, TransModel);
if (err < 0) { print("Error:", err, " On Line:", _context.CurrentLineNum); Exit(); }
class RECT3D SrcObjExtents;
SrcRastObj.GetExtents(SrcObjExtents);
class POINT2D ptUL, ptUR, ptLL, ptLR;
ptUL.x = 0;
ptUL.y = SrcRastObj.GetNumLines();
ptUR.x = SrcRastObj.GetNumColumns();
ptUR.y = SrcRastObj.GetNumLines();
ptLL.x = 0;
ptLL.y = 0;
ptLR.x = SrcRastObj.GetNumColumns();
ptLR.y = 0;
ptUL = TransSrcObjToMap.ConvertPoint2DFwd(ptUL);
ptUR = TransSrcObjToMap.ConvertPoint2DFwd(ptUR);
ptLL = TransSrcObjToMap.ConvertPoint2DFwd(ptLL);
ptLR = TransSrcObjToMap.ConvertPoint2DFwd(ptLR);
# Make the Target raster
class RVC_RASTER TgtRastObj;
# This function call will soon be replaced by future methods added to the RVC_RASTER class
CreateRaster(TgtRastObj, outobjitem.GetFilePath(), outobjitem.GetDescriptor().GetFullName(), outobjitem.GetDescriptor().GetDescription(), SrcRastObj.GetNumLines(), SrcRastObj.GetNumColumns(), RastType(SrcRastObj));
err = TgtRastObj.OpenAttached();
if (err < 0) ReportError(_context.CurrentLineNum, err);
outobjitem = TgtRastObj.GetObjItem();
# Specific projection for the target raster
class SR_COORDREFSYS TgtCRS;
TgtCRS.Create("1200", "2347", "25286"); # NAD83 UTM Zone 13N
# Convert the Source map coordinates to extents in the new projection
class TRANS2D_MAPGEN TransMapSrcToTgt;
TransMapSrcToTgt.InputCoordRefSys = SrcGeorefObj.GetCoordRefSys();
TransMapSrcToTgt.OutputCoordRefsys = TgtCRS;
ptUL = TransMapSrcToTgt.ConvertPoint2DFwd(ptUL);
ptUR = TransMapSrcToTgt.ConvertPoint2DFwd(ptUR);
ptLL = TransMapSrcToTgt.ConvertPoint2DFwd(ptLL);
ptLR = TransMapSrcToTgt.ConvertPoint2DFwd(ptLR);
class RECT3D TgtMapExtents;
TgtMapExtents.SetInvalid();
TgtMapExtents.ExtendPoint(ptUL);
TgtMapExtents.ExtendPoint(ptUR);
TgtMapExtents.ExtendPoint(ptLL);
TgtMapExtents.ExtendPoint(ptLR);
# Create a control point georeference for the Target raster
# This example uses the same number of lines and columns for the
# Target raster as was in the source raster.
class RVC_GEOREFERENCE TgtGeorefObj;
TgtGeorefObj.SetCoordRefSys(TgtCRS);
class CTRLPOINT CtrlPoint[4];
CtrlPoint[1].source.x = 0;
CtrlPoint[1].source.y = 0;
CtrlPoint[1].dest.x = TgtMapExtents.x1;
CtrlPoint[1].dest.y = TgtMapExtents.y2;
CtrlPoint[2].source.x = SrcRastObj.GetNumColumns();
CtrlPoint[2].source.y = 0;
CtrlPoint[2].dest.x = TgtMapExtents.x2;
CtrlPoint[2].dest.y = TgtMapExtents.y2;
CtrlPoint[3].source.x = 0;
CtrlPoint[3].source.y = SrcRastObj.GetNumLines();
CtrlPoint[3].dest.x = TgtMapExtents.x1;
CtrlPoint[3].dest.y = TgtMapExtents.y1;
CtrlPoint[4].source.x = SrcRastObj.GetNumColumns();
CtrlPoint[4].source.y = SrcRastObj.GetNumLines();
CtrlPoint[4].dest.x = TgtMapExtents.x2;
CtrlPoint[4].dest.y = TgtMapExtents.y1;
err = TgtGeorefObj.SetPointList(CtrlPoint);
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = TgtGeorefObj.Make(TgtRastObj);
if (err < 0) ReportError(_context.CurrentLineNum, err);
class TRANS2D_MAPGEN TransTgtToSrc;
err = TgtRastObj.ComputeObjectTranslation(SrcRastObj, TransTgtToSrc);
if (err < 0) ReportError(_context.CurrentLineNum, err);
class IMAGE_PIPELINE_DIMENSIONS Dimensions;
Dimensions.SetTotalDimensions(SrcRastObj.GetNumColumns(), SrcRastObj.GetNumLines());
class IMAGE_PIPELINE_FILTER_RESAMPLE filter_resample(source, Dimensions, TransTgtToSrc, "Nearest");
filter = filter_resample;
}
break;
case "FILTER_SCALEOFFSET":
{
#define by xml control
numeric Scale, Offset;
#
class IMAGE_PIPELINE_FILTER_SCALEOFFSET filter_scaleoffset(source);
numeric i;
for i = 0 to source.GetNumSamples() - 1 {
err = filter_scaleoffset.SetScaleOffset(i, Scale, Offset);
if (err < 0) ReportError(_context.CurrentLineNum, err);
}
filter = filter_scaleoffset;
}
break;
case "FILTER_SELECT":
{
# define by xml control
numeric SampleNum;
#
array numeric SrcSamples[1];
SrcSamples[1] = SampleNum;
class IMAGE_PIPELINE_FILTER_SELECT filter_select(source, SrcSamples, 1);
filter = filter_select;
}
break;
case "FILTER_ZOOM":
{
#define by xml control
string PrevStageUsage$;
string ResampleMethod$;
numeric ZoomScale;
#
class IMAGE_PIPELINE_FILTER_ZOOM filter_zoom(source, ZoomScale, PrevStageUsage$, ResampleMethod$);
filter = filter_zoom;
}
break;
default:
Exit();
break;
}
err = filter.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
###########
### TARGET ###
class IMAGE_PIPELINE_TARGET target;
switch(targettype$) {
case "JPEG":
outfile.SetExtension("JPG");
outfilepath$ = outfile;
class IMAGE_PIPELINE_TARGET_JPEG target_jpeg(filter, outfile);
target = target_jpeg;
break;
case "J2K":
outfile.SetExtension("jp2");
outfilepath$ = outfile;
class IMAGE_PIPELINE_TARGET_J2K_SETTINGS j2ksettings;
class IMAGE_PIPELINE_TARGET_J2K target_j2k(filter, outfile, j2ksettings);
target = target_j2k;
break;
case "PNG":
outfile.SetExtension("png");
outfilepath$ = outfile;
class IMAGE_PIPELINE_TARGET_PNG target_png(filter, outfile);
target = target_png;
break;
case "TIFF":
outfile.SetExtension("TIF");
outfilepath$ = outfile;
class IMAGE_PIPELINE_TARGET_TIFF target_tiff(filter, outfile);
target = target_tiff;
break;
case "RVC":
class IMAGE_PIPELINE_TARGET_RVC target_rvc(filter, outobjitem);
target = target_rvc;
break;
default:
Exit();
break;
}
err = target.Initialize();
if (err < 0) ReportError(_context.CurrentLineNum, err);
err = target.Process();
if (err < 0) ReportError(_context.CurrentLineNum, err);
if (targettype$ == "RVC") {
class RVC_OBJITEM targetobjitem;
targetobjitem.SetFilePath(correctfilepath$);
targetobjitem.SetObjectPath(correctobjectpath$);
if (!targetobjitem.IsExisting()) {#no known good exists
print("FAILED - No correct image exists for ", filtertype$);
if (!correctfile.IsFile()) {
CopyFile(rvcfilepath$, correctfilepath$);
}
CopyObject(rvcfilepath$, 1, correctfilepath$);
}
OpenRaster(RDest, rvcfilepath$, correctobjectpath$);
}
else {
if (!correctfile.IsFile()) { #no known good exists
print("FAILED - No correct image exists for ", filtertype$);
CopyFile(outfilepath$, correctfilepath$);
}
RDest.OpenByName(outfile, outfile.GetNameOnly());
}
######
outfile.Delete();
print("Process Completed");
###
Download