/// <summary> /// <para>Returns, in the blk argument, a block of image data containing the /// specifed rectangular area, in the specified component. The data is /// returned, as a copy of the internal data, therefore the returned data /// can be modified "in place".</para> /// /// <para>The rectangular area to return is specified by the 'ulx', 'uly', 'w' /// and 'h' members of the 'blk' argument, relative to the current /// tile. These members are not modified by this method. The 'offset' of /// the returned data is 0, and the 'scanw' is the same as the block's /// width. See the 'DataBlk' class.</para> /// /// <para>If the data array in 'blk' is 'null', then a new one is created. If /// the data array is not 'null' then it is reused, and it must be large /// enough to contain the block's data. Otherwise an 'ArrayStoreException' /// or an 'IndexOutOfBoundsException' is thrown by the Java system.</para> /// /// <para>The returned data has its 'progressive' attribute set to that of the /// input data.</para> /// /// </summary> /// <param name="blk">Its coordinates and dimensions specify the area to /// return. If it contains a non-null data array, then it must have the /// correct dimensions. If it contains a null data array a new one is /// created. The fields in this object are modified to return the data. /// /// </param> /// <param name="c">The index of the component from which to get the data. Only 0 /// and 3 are valid. /// /// </param> /// <returns> The requested DataBlk /// </returns> /// <seealso cref="getInternCompData"> /// /// </seealso> public override DataBlk getCompData(DataBlk outblk, int c) { int type = outblk.DataType; double colors = Math.Pow(2, src.getNomRangeBits(c)); double bitoff = colors * 0.375D; if (type == DataBlk.TYPE_INT) { DataBlkInt intblk = (DataBlkInt)src.getInternCompData(outblk, c); for (int i = 0; i < intblk.data_array.Length; i++) { int tmp = intblk.data_array[i]; tmp += (int)(colors / 2); tmp -= (int)bitoff; tmp *= 2; tmp -= (int)(colors / 2); intblk.data_array[i] = tmp; } outblk = intblk; } else if (type == DataBlk.TYPE_FLOAT) { FacilityManager.getMsgLogger().printmsg(CSJ2K.j2k.util.MsgLogger_Fields.WARNING, "Unsupported e-sRGB DataType (float)"); DataBlkFloat fltblk = (DataBlkFloat)src.getInternCompData(outblk, c); outblk = fltblk; } return(outblk); }
private static void standardizeMatrixLineThroughLut(DataBlkFloat inb, float[] out_Renamed, float dwInputMaxValue, LookUpTableFP lut) { int j = 0; float wTemp; float[] in_Renamed = (float[])inb.Data; // input pixel reference float[] lutFP = lut.lut; for (int y = inb.uly; y < inb.uly + inb.h; ++y) { for (int x = inb.ulx; x < inb.ulx + inb.w; ++x) { int i = inb.offset + (y - inb.uly) * inb.scanw + (x - inb.ulx); // pixel index. if (in_Renamed[i] > dwInputMaxValue) { wTemp = dwInputMaxValue; } else if (in_Renamed[i] < 0) { wTemp = 0; } else { wTemp = in_Renamed[i]; } //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" out_Renamed[j++] = lutFP[(int)wTemp]; } } }
/// <summary> Output a DataBlkFloat array where each sample in each component /// is the product of the YCC matrix * the vector of samples across /// the input components. /// </summary> /// <param name="inblk">input DataBlkFloat array /// </param> /// <returns> output DataBlkFloat array /// </returns> private static DataBlkFloat[] mult(DataBlkFloat[] inblk) { if (inblk.Length != 3) { throw new System.ArgumentException("bad input array size"); } int i, j; int length = inblk[0].h * inblk[0].w; DataBlkFloat[] outblk = new DataBlkFloat[3]; float[][] out_Renamed = new float[3][]; float[][] in_Renamed = new float[3][]; for (i = 0; i < 3; ++i) { in_Renamed[i] = inblk[i].DataFloat; outblk[i] = new DataBlkFloat(); copyGeometry(outblk[i], inblk[i]); outblk[i].offset = inblk[i].offset; out_Renamed[i] = new float[length]; outblk[i].Data = out_Renamed[i]; } for (j = 0; j < length; ++j) { out_Renamed[0][j] = (Matrix00 * in_Renamed[0][inblk[0].offset + j] + Matrix01 * in_Renamed[1][inblk[1].offset + j] + Matrix02 * in_Renamed[2][inblk[2].offset + j]); out_Renamed[1][j] = (Matrix10 * in_Renamed[0][inblk[0].offset + j] + Matrix11 * in_Renamed[1][inblk[1].offset + j] + Matrix12 * in_Renamed[2][inblk[2].offset + j]); out_Renamed[2][j] = (Matrix20 * in_Renamed[0][inblk[0].offset + j] + Matrix21 * in_Renamed[1][inblk[1].offset + j] + Matrix22 * in_Renamed[2][inblk[2].offset + j]); } return(outblk); }
/// <summary> Populate the output block by looking up the values in the lut, using the input /// as lut indices. /// </summary> /// <param name="inb">input samples /// </param> /// <param name="outb">output samples. /// </param> /// <exception cref="MonochromeTransformException"> /// </exception> public virtual void apply(DataBlkFloat inb, DataBlkFloat outb) { int i, j, o; // x, y removed float[] in_Renamed = (float[])inb.Data; float[] out_Renamed = (float[])outb.Data; if (out_Renamed == null || out_Renamed.Length < in_Renamed.Length) { out_Renamed = new float[in_Renamed.Length]; outb.Data = out_Renamed; outb.uly = inb.uly; outb.ulx = inb.ulx; outb.h = inb.h; outb.w = inb.w; outb.offset = inb.offset; outb.scanw = inb.scanw; } o = inb.offset; for (i = 0; i < inb.h * inb.w; ++i) { //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" j = (int)in_Renamed[i]; if (j < 0) { j = 0; } else if (j > dwInputMaxValue) { j = dwInputMaxValue; } out_Renamed[i] = lut[j]; } }
/// <summary> Output a DataBlkFloat array where each sample in each component /// is the product of the YCC matrix * the vector of samples across /// the input components. /// </summary> /// <param name="inblk">input DataBlkFloat array /// </param> /// <returns> output DataBlkFloat array /// </returns> private static DataBlkFloat[] mult(DataBlkFloat[] inblk) { if (inblk.Length != 3) throw new System.ArgumentException("bad input array size"); int i, j; int length = inblk[0].h * inblk[0].w; DataBlkFloat[] outblk = new DataBlkFloat[3]; float[][] out_Renamed = new float[3][]; float[][] in_Renamed = new float[3][]; for (i = 0; i < 3; ++i) { in_Renamed[i] = inblk[i].DataFloat; outblk[i] = new DataBlkFloat(); copyGeometry(outblk[i], inblk[i]); outblk[i].offset = inblk[i].offset; out_Renamed[i] = new float[length]; outblk[i].Data = out_Renamed[i]; } for (j = 0; j < length; ++j) { out_Renamed[0][j] = (Matrix00 * in_Renamed[0][inblk[0].offset + j] + Matrix01 * in_Renamed[1][inblk[1].offset + j] + Matrix02 * in_Renamed[2][inblk[2].offset + j]); out_Renamed[1][j] = (Matrix10 * in_Renamed[0][inblk[0].offset + j] + Matrix11 * in_Renamed[1][inblk[1].offset + j] + Matrix12 * in_Renamed[2][inblk[2].offset + j]); out_Renamed[2][j] = (Matrix20 * in_Renamed[0][inblk[0].offset + j] + Matrix21 * in_Renamed[1][inblk[1].offset + j] + Matrix22 * in_Renamed[2][inblk[2].offset + j]); } return outblk; }
private static void standardizeMatrixLineThroughLut(DataBlkFloat inb, float[] out_Renamed, float dwInputMaxValue, LookUpTableFP lut) { int j = 0; float wTemp; float[] in_Renamed = (float[]) inb.Data; // input pixel reference float[] lutFP = lut.lut; for (int y = inb.uly; y < inb.uly + inb.h; ++y) { for (int x = inb.ulx; x < inb.ulx + inb.w; ++x) { int i = inb.offset + (y - inb.uly) * inb.scanw + (x - inb.ulx); // pixel index. if (in_Renamed[i] > dwInputMaxValue) wTemp = dwInputMaxValue; else if (in_Renamed[i] < 0) wTemp = 0; else wTemp = in_Renamed[i]; //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" out_Renamed[j++] = lutFP[(int) wTemp]; } } }
/// <summary> Performs the transform. Pass the input throught the LookUpTableFP, apply the /// matrix to the output and finally pass the intermediate buffer through the /// LookUpTable8. This operation is designated (LFP*M*L8) * Data are already /// constructed. Although the data for only one component is returned, the /// transformation must be done for all components, because the matrix application /// involves a linear combination of component input to produce the output. /// </summary> /// <param name="ncols">number of columns in the input /// </param> /// <param name="nrows">number of rows in the input /// </param> /// <param name="inb">input data block /// </param> /// <param name="outb">output data block /// </param> /// <exception cref="MatrixBasedTransformException"> /// </exception> public virtual void apply(DataBlkFloat[] inb, DataBlkFloat[] outb) { float[][] in_Renamed = new float[3][], out_Renamed = new float[3][]; // data references. int nrows = inb[0].h, ncols = inb[0].w; if ((fBuf == null) || (fBuf[0].Length < ncols * nrows)) { float[][] tmpArray = new float[3][]; for (int i = 0; i < 3; i++) { tmpArray[i] = new float[ncols * nrows]; } fBuf = tmpArray; } // for each component (rgb) for (int c = 0; c < 3; ++c) { // Reference the input and output pixels. in_Renamed[c] = (float[]) inb[c].Data; out_Renamed[c] = (float[]) outb[c].Data; // Assure a properly sized output buffer. if (out_Renamed[c] == null || out_Renamed[c].Length < in_Renamed[c].Length) { out_Renamed[c] = new float[in_Renamed[c].Length]; outb[c].Data = out_Renamed[c]; } // The first thing to do is to process the input into a standard form // and through the first input LUT, producing floating point output values standardizeMatrixLineThroughLut(inb[c], fBuf[c], dwMaxValue[c], fLut[c]); } int[] lut32 = lut.lut; // For each row and column int index = 0, val; for (int y = 0; y < inb[0].h; ++y) { int end = index + inb[0].w; while (index < end) { // Calculate the rgb pixel indices for this row / column // Apply the matrix to the intermediate floating point data inorder to index the // final LUT. //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" val = (int) (matrix[M00] * fBuf[RED][index] + matrix[M01] * fBuf[GREEN][index] + matrix[M02] * fBuf[BLUE][index] + 0.5); // Clip the calculated value if necessary.. if (val < 0) out_Renamed[0][index] = lut32[0]; else if (val >= lut32.Length) out_Renamed[0][index] = lut32[lut32.Length - 1]; else out_Renamed[0][index] = lut32[val]; //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" val = (int) (matrix[M10] * fBuf[RED][index] + matrix[M11] * fBuf[GREEN][index] + matrix[M12] * fBuf[BLUE][index] + 0.5); // Clip the calculated value if necessary.. if (val < 0) out_Renamed[1][index] = lut32[0]; else if (val >= lut32.Length) out_Renamed[1][index] = lut32[lut32.Length - 1]; else out_Renamed[1][index] = lut32[val]; //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" val = (int) (matrix[M20] * fBuf[RED][index] + matrix[M21] * fBuf[GREEN][index] + matrix[M22] * fBuf[BLUE][index] + 0.5); // Clip the calculated value if necessary.. if (val < 0) out_Renamed[2][index] = lut32[0]; else if (val >= lut32.Length) out_Renamed[2][index] = lut32[lut32.Length - 1]; else out_Renamed[2][index] = lut32[val]; index++; } } }
/// <summary> Populate the output block by looking up the values in the lut, using the input /// as lut indices. /// </summary> /// <param name="inb">input samples /// </param> /// <param name="outb">output samples. /// </param> /// <exception cref="MonochromeTransformException"> /// </exception> public virtual void apply(DataBlkFloat inb, DataBlkFloat outb) { int i, j, o; // x, y removed float[] in_Renamed = (float[]) inb.Data; float[] out_Renamed = (float[]) outb.Data; if (out_Renamed == null || out_Renamed.Length < in_Renamed.Length) { out_Renamed = new float[in_Renamed.Length]; outb.Data = out_Renamed; outb.uly = inb.uly; outb.ulx = inb.ulx; outb.h = inb.h; outb.w = inb.w; outb.offset = inb.offset; outb.scanw = inb.scanw; } o = inb.offset; for (i = 0; i < inb.h * inb.w; ++i) { //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" j = (int) in_Renamed[i]; if (j < 0) j = 0; else if (j > dwInputMaxValue) j = dwInputMaxValue; out_Renamed[i] = lut[j]; } }