WebSVN – corrade-vassal – Blame – Rev 1 – /libopenmetaverse/CSJ2K/j2k/roi/encoder/ROIScaler.cs

		//UPGRADE_NOTE: Final was removed from the declaration of 'pinfo'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"

160

		private static readonly System.String[][] pinfo = new System.String[][]{new System.String[]{"Rroi", "[<component idx>] R <left> <top> <width> <height>" + " or [<component idx>] C <centre column> <centre row> " + "<radius> or [<component idx>] A <filename>", "Specifies ROIs shape and location. The shape can be either " + "rectangular 'R', or circular 'C' or arbitrary 'A'. " + "Each new occurrence of an 'R', a 'C' or an 'A' is a new ROI. " + "For circular and rectangular ROIs, all values are " + "given as their pixel values relative to the canvas origin. " + "Arbitrary shapes must be included in a PGM file where non 0 " + "values correspond to ROI coefficients. The PGM file must have " + "the size as the image. " + "The component idx specifies which components " + "contain the ROI. The component index is specified as described " + "by points 3 and 4 in the general comment on tile-component idx. " + "If this option is used, the codestream is layer progressive by " + "default unless it is overridden by the 'Aptype' option.", null}, new System.String[]{"Ralign", "[on|off]", "By specifying this argument, the ROI mask will be " + "limited to covering only entire code-blocks. The ROI coding can " + "then be performed without any actual scaling of the coefficients " + "but by instead scaling the distortion estimates.", "off"}, new System.String[]{"Rstart_level", "<level>", "This argument forces the lowest <level> resolution levels to " + "belong to the ROI. By doing this, it is possible to avoid only " + "getting information for the ROI at an early stage of " + "transmission.<level> = 0 means the lowest resolution level " + "belongs to the ROI, 1 means the two lowest etc. (-1 deactivates" + " the option)", "-1"}, new System.String[]{"Rno_rect", "[on|off]", "This argument makes sure that the ROI mask generation is not done " + "using the fast ROI mask generation for rectangular ROIs " + "regardless of whether the specified ROIs are rectangular or not", "off"}};

161

162

/// <summary>The maximum number of magnitude bit-planes in any subband. One value

163

/// for each tile-component

164

/// </summary>

165

private int[][] maxMagBits;

166

167

/// <summary>Flag indicating the presence of ROIs </summary>

168

private bool roi;

169

170

/// <summary>Flag indicating if block aligned ROIs are used </summary>

171

private bool blockAligned;

172

173

/// <summary>Number of resolution levels to include in ROI mask </summary>

174

private int useStartLevel;

175

176

/// <summary>The class generating the ROI mask </summary>

177

private ROIMaskGenerator mg;

178

179

/// <summary>The ROI mask </summary>

180

private DataBlkInt roiMask;

181

182

/// <summary>The source of quantized wavelet transform coefficients </summary>

183

private Quantizer src;

184

185

/// <summary> Constructor of the ROI scaler, takes a Quantizer as source of data to

/// scale.

///

/// </summary>

/// <param name="src">The quantizer that is the source of data.

190

///

191

/// </param>

192

/// <param name="mg">The mask generator that will be used for all components

193

///

194

/// </param>

195

/// <param name="roi">Flag indicating whether there are rois specified.

196

///

197

/// </param>

198

/// <param name="sLev">The resolution levels that belong entirely to ROI

199

///

200

/// </param>

201

/// <param name="uba">Flag indicating whether block aligning is used.

202

///

203

/// </param>

204

/// <param name="encSpec">The encoder specifications for addition of roi specs

205

///

206

/// </param>

207

public ROIScaler(Quantizer src, ROIMaskGenerator mg, bool roi, int sLev, bool uba, EncoderSpecs encSpec):base(src)

{

this.src = src;

this.roi = roi;

this.useStartLevel = sLev;

212

if (roi)

213

{

214

// If there is no ROI, no need to do this

215

this.mg = mg;

216

roiMask = new DataBlkInt();

217

calcMaxMagBits(encSpec);

218

blockAligned = uba;

}

}

/// <summary> Since ROI scaling is always a reversible operation, it calls

223

/// isReversible() method of it source (the quantizer module).

224

///

225

/// </summary>

226

/// <param name="t">The tile to test for reversibility

227

///

228

/// </param>

229

/// <param name="c">The component to test for reversibility

230

///

231

/// </param>

232

/// <returns> True if the quantized data is reversible, false if not.

233

///

234

/// </returns>

235

public virtual bool isReversible(int t, int c)

236

{

237

return src.isReversible(t, c);

238

}

239

240

/// <summary> Returns a reference to the subband tree structure representing the

241

/// subband decomposition for the specified tile-component.

242

///

243

/// </summary>

244

/// <param name="t">The index of the tile.

245

///

246

/// </param>

247

/// <param name="c">The index of the component.

248

///

249

/// </param>

250

/// <returns> The subband tree structure, see SubbandAn.

251

///

252

/// </returns>

253

/// <seealso cref="SubbandAn">

254

///

255

/// </seealso>

256

/// <seealso cref="Subband">

257

///

258

/// </seealso>

259

public virtual SubbandAn getAnSubbandTree(int t, int c)

260

{

261

return src.getAnSubbandTree(t, c);

262

}

263

264

/// <summary> Creates a ROIScaler object. The Quantizer is the source of data to

265

/// scale.

266

///

267

/// The ROI Scaler creates a ROIMaskGenerator depending on what ROI

268

/// information is in the ParameterList. If only rectangular ROI are used,

269

/// the fast mask generator for rectangular ROI can be used.

270

///

271

/// </summary>

272

/// <param name="src">The source of data to scale

273

///

274

/// </param>

275

/// <param name="pl">The parameter list (or options).

276

///

277

/// </param>

278

/// <param name="encSpec">The encoder specifications for addition of roi specs

279

///

280

/// </param>

281

/// <exception cref="IllegalArgumentException">If an error occurs while parsing

282

/// the options in 'pl'

283

///

284

/// </exception>

285

public static ROIScaler createInstance(Quantizer src, ParameterList pl, EncoderSpecs encSpec)

286

{

287

			System.Collections.ArrayList roiVector = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));

288

ROIMaskGenerator maskGen = null;

289

290

// Check parameters

291

pl.checkList(OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(pinfo));

292

293

// Get parameters and check if there are and ROIs specified

294

System.String roiopt = pl.getParameter("Rroi");

295

if (roiopt == null)

296

{

297

// No ROIs specified! Create ROIScaler with no mask generator

298

return new ROIScaler(src, null, false, - 1, false, encSpec);

299

}

300

301

// Check if the lowest resolution levels should belong to the ROI

302

int sLev = pl.getIntParameter("Rstart_level");

303

304

// Check if the ROIs are block-aligned

305

bool useBlockAligned = pl.getBooleanParameter("Ralign");

306

307

// Check if generic mask generation is specified

308

bool onlyRect = !pl.getBooleanParameter("Rno_rect");

309

310

// Parse the ROIs

311

parseROIs(roiopt, src.NumComps, roiVector);

312

ROI[] roiArray = new ROI[roiVector.Count];

313

roiVector.CopyTo(roiArray);

314

315

// If onlyRect has been forced, check if there are any non-rectangular

316

// ROIs specified. Currently, only the presence of circular ROIs will

// make this false

if (onlyRect)

{

for (int i = roiArray.Length - 1; i >= 0; i--)

321

if (!roiArray[i].rect)

{

onlyRect = false;

break;

}

}

if (onlyRect)

{

// It's possible to use the fast ROI mask generation when only

331

// rectangular ROIs are specified.

332

maskGen = new RectROIMaskGenerator(roiArray, src.NumComps);

}

else

{

// It's necessary to use the generic mask generation

337

maskGen = new ArbROIMaskGenerator(roiArray, src.NumComps, src);

338

}

339

return new ROIScaler(src, maskGen, true, sLev, useBlockAligned, encSpec);

340

}

341

342

/// <summary> This function parses the values given for the ROIs with the argument

343

/// -Rroi. Currently only circular and rectangular ROIs are supported.

344

///

345

/// A rectangular ROI is indicated by a 'R' followed the coordinates for

346

/// the upper left corner of the ROI and then its width and height.

347

///

348

/// A circular ROI is indicated by a 'C' followed by the coordinates of

349

/// the circle center and then the radius.

350

///

351

/// Before the R and C values, the component that are affected by the

352

/// ROI are indicated.

353

///

354

/// </summary>

355

/// <param name="roiopt">The info on the ROIs

356

///

357

/// </param>

358

/// <param name="nc">number of components

359

///

360

/// </param>

361

/// <param name="roiVector">The vcector containing the ROI parsed from the cmd line

362

///

363

/// </param>

364

/// <returns> The ROIs specified in roiopt

365

///

366

/// </returns>

367

		protected internal static System.Collections.ArrayList parseROIs(System.String roiopt, int nc, System.Collections.ArrayList roiVector)

{

//ROI[] ROIs;

ROI roi;

SupportClass.Tokenizer stok;

//char tok;

int nrOfROIs = 0;

//char c;

int ulx, uly, w, h, x, y, rad; // comp removed

376

bool[] roiInComp = null;

377

378

stok = new SupportClass.Tokenizer(roiopt);

379

380

System.String word;

381

while (stok.HasMoreTokens())

382

{

383

word = stok.NextToken();

switch (word[0])

{

case 'c': // Components specification

389

roiInComp = ModuleSpec.parseIdx(word, nc);

390

break;

391

392

case 'R': // Rectangular ROI to be read

nrOfROIs++;

try

{

word = stok.NextToken();

397

ulx = (System.Int32.Parse(word));

398

word = stok.NextToken();

399

uly = (System.Int32.Parse(word));

400

word = stok.NextToken();

401

w = (System.Int32.Parse(word));

402

word = stok.NextToken();

403

h = (System.Int32.Parse(word));

404

}

405

catch (System.FormatException)

406

{

407

throw new System.ArgumentException("Bad parameter for " + "'-Rroi R' option : " + word);

408

}

409

catch (System.ArgumentOutOfRangeException)

410

{

411

throw new System.ArgumentException("Wrong number of " + "parameters for " + "h'-Rroi R' option.");

412

}

413

414

// If the ROI is component-specific, check which comps.

415

if (roiInComp != null)

416

for (int i = 0; i < nc; i++)

{

if (roiInComp[i])

{

roi = new ROI(i, ulx, uly, w, h);

421

roiVector.Add(roi);

}

}

else

{

// Otherwise add ROI for all components

427

for (int i = 0; i < nc; i++)

428

{

429

roi = new ROI(i, ulx, uly, w, h);

430

roiVector.Add(roi);

}

}

break;

case 'C': // Circular ROI to be read

nrOfROIs++;

try

{

word = stok.NextToken();

441

x = (System.Int32.Parse(word));

442

word = stok.NextToken();

443

y = (System.Int32.Parse(word));

444

word = stok.NextToken();

445

rad = (System.Int32.Parse(word));

446

}

447

catch (System.FormatException)

448

{

449

throw new System.ArgumentException("Bad parameter for " + "'-Rroi C' option : " + word);

450

}

451

catch (System.ArgumentOutOfRangeException)

452

{

453

throw new System.ArgumentException("Wrong number of " + "parameters for " + "'-Rroi C' option.");

454

}

455

456

// If the ROI is component-specific, check which comps.

457

if (roiInComp != null)

458

for (int i = 0; i < nc; i++)

{

if (roiInComp[i])

{

roi = new ROI(i, x, y, rad);

463

roiVector.Add(roi);

}

}

else

{

// Otherwise add ROI for all components

469

for (int i = 0; i < nc; i++)

470

{

471

roi = new ROI(i, x, y, rad);

472

roiVector.Add(roi);

}

}

break;

case 'A': // ROI wth arbitrary shape

478

nrOfROIs++;

479

480

System.String filename;

481

ImgReaderPGM maskPGM = null;

try

{

filename = stok.NextToken();

486

}

487

catch (System.ArgumentOutOfRangeException)

488

{

489

throw new System.ArgumentException("Wrong number of " + "parameters for " + "'-Rroi A' option.");

}

try

{

maskPGM = new ImgReaderPGM(filename);

494

}

495

catch (System.IO.IOException)

496

{

497

throw new System.ApplicationException("Cannot read PGM file with ROI");

498

}

499

500

// If the ROI is component-specific, check which comps.

501

if (roiInComp != null)

502

for (int i = 0; i < nc; i++)

{

if (roiInComp[i])

{

roi = new ROI(i, maskPGM);

507

roiVector.Add(roi);

}

}

else

{

// Otherwise add ROI for all components

513

for (int i = 0; i < nc; i++)

514

{

515

roi = new ROI(i, maskPGM);

516

roiVector.Add(roi);

}

}

break;

default:

throw new System.ApplicationException("Bad parameters for ROI nr " + roiVector.Count);

}

}

return roiVector;

}

/// <summary> This function gets a datablk from the entropy coder. The sample sin the

531

/// block, which consists of the quantized coefficients from the quantizer,

532

/// are scaled by the values given for any ROIs specified.

533

///

534

/// The function calls on a ROIMaskGenerator to get the mask for scaling

535

/// the coefficients in the current block.

536

///

537

/// The data returned by this method is a copy of the orignal

538

/// data. Therfore it can be modified "in place" without any problems after

539

/// being returned. The 'offset' of the returned data is 0, and the 'scanw'

540

/// is the same as the code-block width. See the 'CBlkWTData' class.

541

///

542

/// </summary>

543

/// <param name="c">The component for which to return the next code-block.

544

///

545

/// </param>

546

/// <param name="cblk">If non-null this object will be used to return the new

547

/// code-block. If null a new one will be allocated and returned. If the

548

/// "data" array of the object is non-null it will be reused, if possible,

549

/// to return the data.

550

///

551

/// </param>

552

/// <returns> The next code-block in the current tile for component 'n', or

553

/// null if all code-blocks for the current tile have been returned.

554

///

555

/// </returns>

556

/// <seealso cref="CBlkWTData">

557

///

558

/// </seealso>

559

public virtual CBlkWTData getNextCodeBlock(int c, CBlkWTData cblk)

560

{

561

return getNextInternCodeBlock(c, cblk);

562

}

563

564

/// <summary> This function gets a datablk from the entropy coder. The sample sin the

565

/// block, which consists of the quantized coefficients from the quantizer,

566

/// are scaled by the values given for any ROIs specified.

567

///

568

/// The function calls on a ROIMaskGenerator to get the mask for scaling

569

/// the coefficients in the current block.

570

///

571

/// </summary>

572

/// <param name="c">The component for which to return the next code-block.

573

///

574

/// </param>

575

/// <param name="cblk">If non-null this object will be used to return the new

576

/// code-block. If null a new one will be allocated and returned. If the

577

/// "data" array of the object is non-null it will be reused, if possible,

578

/// to return the data.

579

///

580

/// </param>

581

/// <returns> The next code-block in the current tile for component 'n', or

582

/// null if all code-blocks for the current tile have been returned.

583

///

584

/// </returns>

585

/// <seealso cref="CBlkWTData">

586

///

587

/// </seealso>

588

public virtual CBlkWTData getNextInternCodeBlock(int c, CBlkWTData cblk)

589

{

590

int mi, i, j, k, wrap;

591

int ulx, uly, w, h;

592

DataBlkInt mask = roiMask; // local copy of mask

593

int[] maskData; // local copy of mask data

594

int[] data; // local copy of quantized data

595

int tmp;

596

int bitMask = 0x7FFFFFFF;

597

SubbandAn root, sb;

598

int maxBits = 0; // local copy

bool roiInTile;

bool sbInMask;

int nROIcoeff = 0;

// Get codeblock's data from quantizer

604

cblk = src.getNextCodeBlock(c, cblk);

605

606

// If there is no ROI in the image, or if we already got all

607

// code-blocks

608

if (!roi || cblk == null)

{

return cblk;

}

data = (int[]) cblk.Data;

sb = cblk.sb;

ulx = cblk.ulx;

uly = cblk.uly;

w = cblk.w;

h = cblk.h;

sbInMask = (sb.resLvl <= useStartLevel);

620

621

// Check that there is an array for the mask and set it to zero

622

maskData = mask.DataInt; // local copy of mask data

623

if (maskData == null || w * h > maskData.Length)

624

{

625

maskData = new int[w * h];

626

mask.DataInt = maskData;

}

else

{

for (i = w * h - 1; i >= 0; i--)

maskData[i] = 0;

}

mask.ulx = ulx;

mask.uly = uly;

mask.w = w;

mask.h = h;

// Get ROI mask from generator

639

root = src.getAnSubbandTree(tIdx, c);

640

maxBits = maxMagBits[tIdx][c];

641

roiInTile = mg.getROIMask(mask, root, maxBits, c);

642

643

// If there is no ROI in this tile, return the code-block untouched

644

if (!roiInTile && (!sbInMask))

{

cblk.nROIbp = 0;

return cblk;

}

// Update field containing the number of ROI magnitude bit-planes

651

cblk.nROIbp = cblk.magbits;

652

653

// If the entire subband belongs to the ROI mask, The code-block is

654

// set to belong entirely to the ROI with the highest scaling value

655

if (sbInMask)

656

{

657

// Scale the wmse so that instead of scaling the coefficients, the

658

// wmse is scaled.

659

				//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'"

660

cblk.wmseScaling *= (float) (1 << (maxBits << 1));

661

cblk.nROIcoeff = w * h;

return cblk;

}

// In 'block aligned' mode, the code-block is set to belong entirely

666

// to the ROI with the highest scaling value if one coefficient, at

667

// least, belongs to the ROI

668

if (blockAligned)

669

{

670

wrap = cblk.scanw - w;

671

mi = h * w - 1;

672

i = cblk.offset + cblk.scanw * (h - 1) + w - 1;

673

int nroicoeff = 0;

674

for (j = h; j > 0; j--)

675

{

676

for (k = w - 1; k >= 0; k--, i--, mi--)

677

{

678

if (maskData[mi] != 0)

{

nroicoeff++;

}

}

i -= wrap;

}

if (nroicoeff != 0)

686

{

687

// Include the subband

688

					//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'"

689

cblk.wmseScaling *= (float) (1 << (maxBits << 1));

690

cblk.nROIcoeff = w * h;

}

return cblk;

}

// Scale background coefficients

696

bitMask = (((1 << cblk.magbits) - 1) << (31 - cblk.magbits));

697

wrap = cblk.scanw - w;

698

mi = h * w - 1;

699

i = cblk.offset + cblk.scanw * (h - 1) + w - 1;

700

for (j = h; j > 0; j--)

701

{

702

for (k = w; k > 0; k--, i--, mi--)

703

{

704

tmp = data[i];

705

if (maskData[mi] != 0)

706

{

707

// ROI coeff. We need to erase fractional bits to ensure

708

// that they do not conflict with BG coeffs. This is only

709

// strictly necessary for ROI coeffs. which non-fractional

710

// magnitude is zero, but much better BG quality can be

711

// achieved if done if reset to zero since coding zeros is

712

// much more efficient (the entropy coder knows nothing

713

// about ROI and cannot avoid coding the ROI fractional

714

// bits, otherwise this would not be necessary).

715

data[i] = (unchecked((int) 0x80000000) & tmp) | (tmp & bitMask);

nROIcoeff++;

}

else

{

// BG coeff. it is not necessary to erase fractional bits

721

data[i] = (unchecked((int) 0x80000000) & tmp) | ((tmp & 0x7FFFFFFF) >> maxBits);

}

}

i -= wrap;

}

// Modify the number of significant bit-planes in the code-block

728

cblk.magbits += maxBits;

729

730

// Store the number of ROI coefficients present in the code-block

731

cblk.nROIcoeff = nROIcoeff;

return cblk;

}

/// <summary> This function returns the flag indicating if any ROI functionality used

737

///

738

/// </summary>

739

/// <returns> Flag indicating whether there are ROIs in the image

740

/// </returns>

741

public virtual bool useRoi()

{

return roi;

}

/// <summary> Changes the current tile, given the new indexes. An

747

/// IllegalArgumentException is thrown if the indexes do not

748

/// correspond to a valid tile.

749

///

750

/// </summary>

751

/// <param name="x">The horizontal index of the tile.

752

///

753

/// </param>

754

/// <param name="y">The vertical index of the new tile.

755

///

756

/// </param>

757

public override void setTile(int x, int y)

758

{

759

base.setTile(x, y);

if (roi)

mg.tileChanged();

}

/// <summary> Advances to the next tile, in standard scan-line order (by rows then

765

/// columns). An NoNextElementException is thrown if the current tile is

766

/// the last one (i.e. there is no next tile).

767

///

768

/// </summary>

769

public override void nextTile()

{

base.nextTile();

if (roi)

mg.tileChanged();

}

/// <summary> Calculates the maximum amount of magnitude bits for each

777

/// tile-component, and stores it in the 'maxMagBits' array. This is called

778

/// by the constructor

779

///

780

/// </summary>

781

/// <param name="encSpec">The encoder specifications for addition of roi specs

782

///

783

/// </param>

784

private void calcMaxMagBits(EncoderSpecs encSpec)

785

{

786

int tmp;

787

MaxShiftSpec rois = encSpec.rois;

788

789

int nt = src.getNumTiles();

790

int nc = src.NumComps;

791

792

maxMagBits = new int[nt][];

793

for (int i = 0; i < nt; i++)

794

{

795

maxMagBits[i] = new int[nc];

}

src.setTile(0, 0);

for (int t = 0; t < nt; t++)

800

{

801

for (int c = nc - 1; c >= 0; c--)

802

{

803

tmp = src.getMaxMagBits(c);

804

maxMagBits[t][c] = tmp;

805

rois.setTileCompVal(t, c, (System.Object) tmp);

}

if (t < nt - 1)

src.nextTile();

}

// Reset to current initial tile position

src.setTile(0, 0);

}

}

}

corrade-vassal – Blame information for rev 1