/// <summary> Initializes this object with the given source of image data and with
/// all the decompositon parameters
///
/// </summary>
/// <param name="src">From where the image data should be obtained.
///
/// </param>
/// <param name="encSpec">The encoder specifications
///
/// </param>
/// <param name="cb0x">The horizontal coordinate of the code-block partition
/// origin on the reference grid.
///
/// </param>
/// <param name="cb0y">The vertical coordinate of the code-block partition origin
/// on the reference grid.
///
/// </param>
/// <seealso cref="ForwardWT">
///
/// </seealso>
public ForwWTFull(BlkImgDataSrc src, EncoderSpecs encSpec, int cb0x, int cb0y) : base(src)
{
this.src = src;
this.cb0x = cb0x;
this.cb0y = cb0y;
this.dls = encSpec.dls;
this.filters = encSpec.wfs;
this.cblks = encSpec.cblks;
this.pss = encSpec.pss;
int ncomp = src.NumComps;
int ntiles = src.getNumTiles();
currentSubband = new SubbandAn[ncomp];
decomposedComps = new DataBlk[ncomp];
subbTrees = new SubbandAn[ntiles][];
for (int i = 0; i < ntiles; i++)
{
subbTrees[i] = new SubbandAn[ncomp];
}
lastn = new int[ncomp];
lastm = new int[ncomp];
}
/// <summary> Constructs a new 'ForwCompTransfSpec' for the specified number of
/// components and tiles, the wavelet filters type and the parameter of the
/// option 'Mct'. This constructor is called by the encoder. It also checks
/// that the arguments belong to the recognized arguments list.
///
/// <p>This constructor chose the component transformation type depending
/// on the wavelet filters : RCT with w5x3 filter and ICT with w9x7
/// filter. Note: All filters must use the same data type.</p>
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="wfs">The wavelet filter specifications
///
/// </param>
/// <param name="pl">The ParameterList
///
/// </param>
public ForwCompTransfSpec(int nt, int nc, byte type, AnWTFilterSpec wfs, ParameterList pl):base(nt, nc, type)
{
System.String param = pl.getParameter("Mct");
if (param == null)
{
// The option has not been specified
// If less than three component, do not use any component
// transformation
if (nc < 3)
{
setDefault("none");
return ;
}
// If the compression is lossless, uses RCT
else if (pl.getBooleanParameter("lossless"))
{
setDefault("rct");
return ;
}
else
{
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < 3; c++)
{
anfilt = (AnWTFilter[][]) wfs.getCompDef(c);
filtType[c] = anfilt[0][0].FilterType;
}
// Check that the three first components use the same filters
bool reject = false;
for (int c = 1; c < 3; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
setDefault("none");
}
else
{
anfilt = (AnWTFilter[][]) wfs.getCompDef(0);
if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7)
{
setDefault("ict");
}
else
{
setDefault("rct");
}
}
}
// Each tile receives a component transform specification
// according the type of wavelet filters that are used by the
// three first components
for (int t = 0; t < nt; t++)
{
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < 3; c++)
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c);
filtType[c] = anfilt[0][0].FilterType;
}
// Check that the three components use the same filters
bool reject = false;
for (int c = 1; c < nComp; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
setTileDef(t, "none");
}
else
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, 0);
if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7)
{
setTileDef(t, "ict");
}
else
{
setTileDef(t, "rct");
}
}
}
return ;
}
// Parse argument
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
System.String word; // current word
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the
// specification
//System.Boolean value_Renamed;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
throw new System.ArgumentException("Component specific " + " parameters" + " not allowed with " + "'-Mct' option");
default:
if (word.Equals("off"))
{
if (curSpecType == SPEC_DEF)
{
setDefault("none");
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
if (tileSpec[i])
{
setTileDef(i, "none");
}
}
}
else if (word.Equals("on"))
{
if (nc < 3)
{
throw new System.ArgumentException("Cannot use component" + " transformation on a " + "image with less than " + "three components");
}
if (curSpecType == SPEC_DEF)
{
// Set arbitrarily the default
// value to RCT (later will be found the suitable
// component transform for each tile)
setDefault("rct");
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
if (tileSpec[i])
{
if (getFilterType(i, wfs) == CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3)
{
setTileDef(i, "rct");
}
else
{
setTileDef(i, "ict");
}
}
}
}
}
else
{
throw new System.ArgumentException("Default parameter of " + "option Mct not" + " recognized: " + param);
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
break;
}
}
// Check that default value has been specified
if (getDefault() == null)
{
// If not, set arbitrarily the default value to 'none' but
// specifies explicitely a default value for each tile depending
// on the wavelet transform that is used
setDefault("none");
for (int t = 0; t < nt; t++)
{
if (isTileSpecified(t))
{
continue;
}
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < 3; c++)
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c);
filtType[c] = anfilt[0][0].FilterType;
}
// Check that the three components use the same filters
bool reject = false;
for (int c = 1; c < nComp; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
setTileDef(t, "none");
}
else
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, 0);
if (anfilt[0][0].FilterType == CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7)
{
setTileDef(t, "ict");
}
else
{
setTileDef(t, "rct");
}
}
}
}
// Check validity of component transformation of each tile compared to
// the filter used.
for (int t = nt - 1; t >= 0; t--)
{
if (((System.String) getTileDef(t)).Equals("none"))
{
// No comp. transf is used. No check is needed
continue;
}
else if (((System.String) getTileDef(t)).Equals("rct"))
{
// Tile is using Reversible component transform
int filterType = getFilterType(t, wfs);
switch (filterType)
{
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3: // OK
break;
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7: // Must use ICT
if (isTileSpecified(t))
{
// User has requested RCT -> Error
throw new System.ArgumentException("Cannot use RCT " + "with 9x7 filter " + "in tile " + t);
}
else
{
// Specify ICT for this tile
setTileDef(t, "ict");
}
break;
default:
throw new System.ArgumentException("Default filter is " + "not JPEG 2000 part" + " I compliant");
}
}
else
{
// ICT
int filterType = getFilterType(t, wfs);
switch (filterType)
{
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W5X3: // Must use RCT
if (isTileSpecified(t))
{
// User has requested ICT -> Error
throw new System.ArgumentException("Cannot use ICT " + "with filter 5x3 " + "in tile " + t);
}
else
{
setTileDef(t, "rct");
}
break;
case CSJ2K.j2k.wavelet.FilterTypes_Fields.W9X7: // OK
break;
default:
throw new System.ArgumentException("Default filter is " + "not JPEG 2000 part" + " I compliant");
}
}
}
}
/// <summary> Get the filter type common to all component of a given tile. If the
/// tile index is -1, it searches common filter type of default
/// specifications.
///
/// </summary>
/// <param name="t">The tile index
///
/// </param>
/// <param name="wfs">The analysis filters specifications
///
/// </param>
/// <returns> The filter type common to all the components
///
/// </returns>
private int getFilterType(int t, AnWTFilterSpec wfs)
{
AnWTFilter[][] anfilt;
int[] filtType = new int[nComp];
for (int c = 0; c < nComp; c++)
{
if (t == - 1)
{
anfilt = (AnWTFilter[][]) wfs.getCompDef(c);
}
else
{
anfilt = (AnWTFilter[][]) wfs.getTileCompVal(t, c);
}
filtType[c] = anfilt[0][0].FilterType;
}
// Check that all filters are the same one
bool reject = false;
for (int c = 1; c < nComp; c++)
{
if (filtType[c] != filtType[0])
reject = true;
}
if (reject)
{
throw new System.ArgumentException("Can not use component" + " transformation when " + "components do not use " + "the same filters");
}
return filtType[0];
}
/// <summary> Initializes this object with the given source of image data and with
/// all the decompositon parameters
///
/// </summary>
/// <param name="src">From where the image data should be obtained.
///
/// </param>
/// <param name="encSpec">The encoder specifications
///
/// </param>
/// <param name="cb0x">The horizontal coordinate of the code-block partition
/// origin on the reference grid.
///
/// </param>
/// <param name="cb0y">The vertical coordinate of the code-block partition origin
/// on the reference grid.
///
/// </param>
/// <seealso cref="ForwardWT">
///
/// </seealso>
public ForwWTFull(BlkImgDataSrc src, EncoderSpecs encSpec, int cb0x, int cb0y):base(src)
{
this.src = src;
this.cb0x = cb0x;
this.cb0y = cb0y;
this.dls = encSpec.dls;
this.filters = encSpec.wfs;
this.cblks = encSpec.cblks;
this.pss = encSpec.pss;
int ncomp = src.NumComps;
int ntiles = src.getNumTiles();
currentSubband = new SubbandAn[ncomp];
decomposedComps = new DataBlk[ncomp];
subbTrees = new SubbandAn[ntiles][];
for (int i = 0; i < ntiles; i++)
{
subbTrees[i] = new SubbandAn[ncomp];
}
lastn = new int[ncomp];
lastm = new int[ncomp];
}
/// <summary> Initialize all members with the given number of tiles and components
/// and the command-line arguments stored in a ParameterList instance
///
/// </summary>
/// <param name="nt">Number of tiles
///
/// </param>
/// <param name="nc">Number of components
///
/// </param>
/// <param name="imgsrc">The image source (used to get the image size)
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public EncoderSpecs(int nt, int nc, BlkImgDataSrc imgsrc, ParameterList pl)
{
nTiles = nt;
nComp = nc;
// ROI
rois = new MaxShiftSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Quantization
pl.checkList(Quantizer.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(Quantizer.ParameterInfo));
qts = new QuantTypeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
qsss = new QuantStepSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
gbs = new GuardBitsSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
// Wavelet transform
wfs = new AnWTFilterSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, qts, pl);
dls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl, "Wlev");
// Component transformation
cts = new ForwCompTransfSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, wfs, pl);
// Entropy coder
System.String[] strLcs = new System.String[]{"near_opt", "lazy_good", "lazy"};
lcs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Clen_calc", strLcs, pl);
System.String[] strTerm = new System.String[]{"near_opt", "easy", "predict", "full"};
tts = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cterm_type", strTerm, pl);
System.String[] strBoolean = new System.String[]{"on", "off"};
sss = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cseg_symbol", strBoolean, pl);
css = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Ccausal", strBoolean, pl);
rts = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cterminate", strBoolean, pl);
mqrs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "CresetMQ", strBoolean, pl);
bms = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cbypass", strBoolean, pl);
cblks = new CBlkSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
// Precinct partition
pss = new PrecinctSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, imgsrc, dls, pl);
// Codestream
sops = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, "Psop", strBoolean, pl);
ephs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, "Peph", strBoolean, pl);
}
/// <summary> Constructs a new ForwCompTransf object that operates on the specified
/// source of image data.
///
/// </summary>
/// <param name="imgSrc">The source from where to get the data to be transformed
///
/// </param>
/// <param name="encSpec">The encoder specifications
///
/// </param>
/// <seealso cref="BlkImgDataSrc">
///
/// </seealso>
public ForwCompTransf(BlkImgDataSrc imgSrc, EncoderSpecs encSpec):base(imgSrc)
{
this.cts = encSpec.cts;
this.wfs = encSpec.wfs;
src = imgSrc;
}