~ubuntu-branches/ubuntu/gutsy/amsn/gutsy

RGBQUAD GetPixelColorInterpolated(float x,float y, InterpolationMethod const inMethod=IM_BILINEAR, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);

352

RGBQUAD GetAreaColorInterpolated(float const xc, float const yc, float const w, float const h, InterpolationMethod const inMethod, OverflowMethod const ofMethod=OM_BACKGROUND, RGBQUAD* const rplColor=0);

353

//@}

354

355

protected:

356

/** \addtogroup Protected */ //@{

357

void AddAveragingCont(RGBQUAD const &color, float const surf, float &rr, float &gg, float &bb, float &aa);

358

//@}

359

360

/** \addtogroup Kernels */ //@{

361

public:

362

static float KernelBSpline(const float x);

363

static float KernelLinear(const float t);

364

static float KernelCubic(const float t);

365

static float KernelGeneralizedCubic(const float t, const float a=-1);

366

static float KernelLanczosSinc(const float t, const float r = 3);

367

static float KernelBox(const float x);

368

static float KernelHermite(const float x);

369

static float KernelHamming(const float x);

370

static float KernelSinc(const float x);

371

static float KernelBlackman(const float x);

372

static float KernelBessel_J1(const float x);

373

static float KernelBessel_P1(const float x);

374

static float KernelBessel_Q1(const float x);

375

static float KernelBessel_Order1(float x);

376

static float KernelBessel(const float x);

377

static float KernelGaussian(const float x);

378

static float KernelQuadratic(const float x);

379

static float KernelMitchell(const float x);

380

static float KernelCatrom(const float x);

381

//@}

382

#endif //CXIMAGE_SUPPORT_INTERPOLATION

383

384

/** \addtogroup Painting */ //@{

385

#if CXIMAGE_SUPPORT_WINCE

386

long Blt(HDC pDC, long x=0, long y=0);

387

#endif

388

#if CXIMAGE_SUPPORT_WINDOWS

389

HBITMAP MakeBitmap(HDC hdc = NULL);

390

HANDLE CopyToHandle();

391

bool CreateFromHANDLE(HANDLE hMem); //Windows objects (clipboard)

392

bool CreateFromHBITMAP(HBITMAP hbmp, HPALETTE hpal=0); //Windows resource

393

bool CreateFromHICON(HICON hico);

394

long Draw(HDC hdc, long x=0, long y=0, long cx = -1, long cy = -1, RECT* pClipRect = 0, bool bSmooth = false);

395

long Draw(HDC hdc, const RECT& rect, RECT* pClipRect=NULL, bool bSmooth = false);

396

long Stretch(HDC hdc, long xoffset, long yoffset, long xsize, long ysize, DWORD dwRop = SRCCOPY);

397

long Stretch(HDC hdc, const RECT& rect, DWORD dwRop = SRCCOPY);

398

long Tile(HDC hdc, RECT *rc);

399

long Draw2(HDC hdc, long x=0, long y=0, long cx = -1, long cy = -1);

400

long Draw2(HDC hdc, const RECT& rect);

401

//long DrawString(HDC hdc, long x, long y, const char* text, RGBQUAD color, const char* font, long lSize=0, long lWeight=400, BYTE bItalic=0, BYTE bUnderline=0, bool bSetAlpha=false);

402

long DrawString(HDC hdc, long x, long y, const TCHAR* text, RGBQUAD color, const TCHAR* font, long lSize=0, long lWeight=400, BYTE bItalic=0, BYTE bUnderline=0, bool bSetAlpha=false);

403

// <VATI> extensions

404

long DrawStringEx(HDC hdc, long x, long y, CXTEXTINFO *pTextType, bool bSetAlpha=false );

405

void InitTextInfo( CXTEXTINFO *txt );

406

#endif //CXIMAGE_SUPPORT_WINDOWS

407

//@}

408

409

// file operations

410

#if CXIMAGE_SUPPORT_DECODE

411

/** \addtogroup Decode */ //@{

412

#ifdef WIN32

413

//bool Load(LPCWSTR filename, DWORD imagetype=0);

414

bool LoadResource(HRSRC hRes, DWORD imagetype, HMODULE hModule=NULL);

415

#endif

416

// For UNICODE support: char -> TCHAR

417

bool Load(const TCHAR* filename, DWORD imagetype=0);

418

//bool Load(const char * filename, DWORD imagetype=0);

419

bool Decode(FILE * hFile, DWORD imagetype);

420

bool Decode(CxFile * hFile, DWORD imagetype);

421

bool Decode(BYTE * buffer, DWORD size, DWORD imagetype);

422

//@}

423

#endif //CXIMAGE_SUPPORT_DECODE

424

425

#if CXIMAGE_SUPPORT_ENCODE

426

protected:

427

/** \addtogroup Protected */ //@{

428

bool EncodeSafeCheck(CxFile *hFile);

429

//@}

430

431

public:

432

/** \addtogroup Encode */ //@{

433

#ifdef WIN32

434

//bool Save(LPCWSTR filename, DWORD imagetype=0);

435

#endif

436

// For UNICODE support: char -> TCHAR

437

bool Save(const TCHAR* filename, DWORD imagetype);

438

//bool Save(const char * filename, DWORD imagetype=0);

439

bool Encode(FILE * hFile, DWORD imagetype);

440

bool Encode(CxFile * hFile, DWORD imagetype);

441

bool Encode(CxFile * hFile, CxImage ** pImages, int pagecount, DWORD imagetype);

442

bool Encode(FILE *hFile, CxImage ** pImages, int pagecount, DWORD imagetype);

443

bool Encode(BYTE * &buffer, long &size, DWORD imagetype);

444

445

bool Encode2RGBA(CxFile *hFile);

446

bool Encode2RGBA(BYTE * &buffer, long &size);

447

//@}

448

#endif //CXIMAGE_SUPPORT_ENCODE

449

450

/** \addtogroup Attributes */ //@{

451

//misc.

452

bool IsValid() const;

453

bool IsEnabled() const;

454

void Enable(bool enable=true);

455

456

// frame operations

457

long GetNumFrames() const;

458

long GetFrame() const;

459

void SetFrame(long nFrame);

460

461

CxImage * GetFrameNo(long nFrame) const;

462

void RetreiveAllFrame();

463

void RetreiveSingleFrame();

464

//@}

465

466

#if CXIMAGE_SUPPORT_BASICTRANSFORMATIONS

467

/** \addtogroup BasicTransformations */ //@{

468

bool GrayScale();

469

bool Flip();

470

bool Mirror();

471

bool Negative();

472

bool RotateLeft(CxImage* iDst = NULL);

473

bool RotateRight(CxImage* iDst = NULL);

474

//@}

475

#endif //CXIMAGE_SUPPORT_BASICTRANSFORMATIONS

476

477

#if CXIMAGE_SUPPORT_TRANSFORMATION

478

/** \addtogroup Transformations */ //@{

479

// image operations

480

bool Rotate(float angle, CxImage* iDst = NULL);

481

bool Rotate2(float angle, CxImage *iDst = NULL, InterpolationMethod inMethod=IM_BILINEAR,

482

OverflowMethod ofMethod=OM_BACKGROUND, RGBQUAD *replColor=0,

483

bool const optimizeRightAngles=true, bool const bKeepOriginalSize=false);

484

bool Rotate180(CxImage* iDst = NULL);

485

bool Resample(long newx, long newy, int mode = 1, CxImage* iDst = NULL);

486

bool Resample2(long newx, long newy, InterpolationMethod const inMethod=IM_BICUBIC2,

487

OverflowMethod const ofMethod=OM_REPEAT, CxImage* const iDst = NULL,

488

bool const disableAveraging=false);

489

bool DecreaseBpp(DWORD nbit, bool errordiffusion, RGBQUAD* ppal = 0, DWORD clrimportant = 0);

490

bool IncreaseBpp(DWORD nbit);

491

bool Dither(long method = 0);

492

bool Crop(long left, long top, long right, long bottom, CxImage* iDst = NULL);

493

bool Crop(const RECT& rect, CxImage* iDst = NULL);

494

bool CropRotatedRectangle( long topx, long topy, long width, long height, float angle, CxImage* iDst = NULL);

495

bool Skew(float xgain, float ygain, long xpivot=0, long ypivot=0, bool bEnableInterpolation = false);

496

bool Expand(long left, long top, long right, long bottom, RGBQUAD canvascolor, CxImage* iDst = 0);

497

bool Expand(long newx, long newy, RGBQUAD canvascolor, CxImage* iDst = 0);

498

bool Thumbnail(long newx, long newy, RGBQUAD canvascolor, CxImage* iDst = 0);

499

bool CircleTransform(int type,long rmax=0,float Koeff=1.0f);

500

bool RedEyeRemove();

501

bool QIShrink(long newx, long newy, CxImage* const iDst = NULL);

502

//@}

503

#endif //CXIMAGE_SUPPORT_TRANSFORMATION

504

505

#if CXIMAGE_SUPPORT_DSP

506

/** \addtogroup DSP */ //@{

507

bool Contour();

508

bool HistogramStretch(long method = 0);

509

bool HistogramEqualize();

510

bool HistogramNormalize();

511

bool HistogramRoot();

512

bool HistogramLog();

513

long Histogram(long* red, long* green = 0, long* blue = 0, long* gray = 0, long colorspace = 0);

514

bool Jitter(long radius=2);

515

bool Repair(float radius = 0.25f, long niterations = 1, long colorspace = 0);

516

bool Combine(CxImage* r,CxImage* g,CxImage* b,CxImage* a, long colorspace = 0);

517

bool FFT2(CxImage* srcReal, CxImage* srcImag, CxImage* dstReal, CxImage* dstImag, long direction = 1, bool bForceFFT = true, bool bMagnitude = true);

518

bool Noise(long level);

519

bool Median(long Ksize=3);

520

bool Gamma(float gamma);

521

bool ShiftRGB(long r, long g, long b);

522

bool Threshold(BYTE level);

523

bool Colorize(BYTE hue, BYTE sat, float blend = 1.0f);

524

bool Light(long brightness, long contrast = 0);

525

float Mean();

526

bool Filter(long* kernel, long Ksize, long Kfactor, long Koffset);

527

bool Erode(long Ksize=2);

528

bool Dilate(long Ksize=2);

529

bool Edge(long Ksize=2);

530

void HuePalette(float correction=1);

531

enum ImageOpType { OpAdd, OpAnd, OpXor, OpOr, OpMask, OpSrcCopy, OpDstCopy, OpSub, OpSrcBlend, OpScreen };

532

void Mix(CxImage & imgsrc2, ImageOpType op, long lXOffset = 0, long lYOffset = 0, bool bMixAlpha = false);

533

void MixFrom(CxImage & imagesrc2, long lXOffset, long lYOffset);

534

bool UnsharpMask(float radius = 5.0, float amount = 0.5, int threshold = 0);

535

bool Lut(BYTE* pLut);

536

bool Lut(BYTE* pLutR, BYTE* pLutG, BYTE* pLutB, BYTE* pLutA = 0);

537

//@}

538

539

protected:

540

/** \addtogroup Protected */ //@{

541

bool IsPowerof2(long x);

542

bool FFT(int dir,int m,double *x,double *y);

543

bool DFT(int dir,long m,double *x1,double *y1,double *x2,double *y2);

544

bool RepairChannel(CxImage *ch, float radius);

545

// <nipper>

546

int gen_convolve_matrix (float radius, float **cmatrix_p);

547

float* gen_lookup_table (float *cmatrix, int cmatrix_length);

548

void blur_line (float *ctable, float *cmatrix, int cmatrix_length, BYTE* cur_col, BYTE* dest_col, int y, long bytes);

549

//@}

550

551

public:

552

/** \addtogroup ColorSpace */ //@{

553

bool SplitRGB(CxImage* r,CxImage* g,CxImage* b);

554

bool SplitYUV(CxImage* y,CxImage* u,CxImage* v);

555

bool SplitHSL(CxImage* h,CxImage* s,CxImage* l);

556

bool SplitYIQ(CxImage* y,CxImage* i,CxImage* q);

557

bool SplitXYZ(CxImage* x,CxImage* y,CxImage* z);

558

bool SplitCMYK(CxImage* c,CxImage* m,CxImage* y,CxImage* k);

559

static RGBQUAD HSLtoRGB(COLORREF cHSLColor);

560

static RGBQUAD RGBtoHSL(RGBQUAD lRGBColor);

561

static RGBQUAD HSLtoRGB(RGBQUAD lHSLColor);

562

static RGBQUAD YUVtoRGB(RGBQUAD lYUVColor);

563

static RGBQUAD RGBtoYUV(RGBQUAD lRGBColor);

564

static RGBQUAD YIQtoRGB(RGBQUAD lYIQColor);

565

static RGBQUAD RGBtoYIQ(RGBQUAD lRGBColor);

566

static RGBQUAD XYZtoRGB(RGBQUAD lXYZColor);

567

static RGBQUAD RGBtoXYZ(RGBQUAD lRGBColor);

568

#endif //CXIMAGE_SUPPORT_DSP

569

static RGBQUAD RGBtoRGBQUAD(COLORREF cr);

570

static COLORREF RGBQUADtoRGB (RGBQUAD c);

571

//@}

572

573

#if CXIMAGE_SUPPORT_SELECTION

574

/** \addtogroup Selection */ //@{

575

bool SelectionClear();

576

bool SelectionCreate();

577

bool SelectionDelete();

578

bool SelectionInvert();

579

bool SelectionAddRect(RECT r);

580

bool SelectionAddEllipse(RECT r);

581

bool SelectionAddPolygon(POINT *points, long npoints);

582

bool SelectionAddColor(RGBQUAD c);

583

bool SelectionAddPixel(int x, int y);

584

bool SelectionCopy(CxImage &from);

585

bool SelectionIsInside(long x, long y);

586

bool SelectionIsValid();

587

void SelectionGetBox(RECT& r);

588

bool SelectionToHRGN(HRGN& region);

589

bool SelectionSplit(CxImage *dest);

590

//@}

591

#endif //CXIMAGE_SUPPORT_SELECTION

592

593

#if CXIMAGE_SUPPORT_ALPHA

594

/** \addtogroup Alpha */ //@{

595

void AlphaClear();

596

void AlphaCreate();

597

void AlphaDelete();

598

void AlphaInvert();

599

bool AlphaMirror();

600

bool AlphaFlip();

601

bool AlphaCopy(CxImage &from);

602

bool AlphaSplit(CxImage *dest);

603

void AlphaStrip();

604

void AlphaSet(BYTE level);

605

bool AlphaSet(CxImage &from);

606

void AlphaSet(const long x,const long y,const BYTE level);

607

BYTE AlphaGet(const long x,const long y);

608

BYTE AlphaGetMax() const;

609

void AlphaSetMax(BYTE nAlphaMax);

610

bool AlphaIsValid();

611

BYTE* AlphaGetPointer(const long x = 0,const long y = 0);

612

613

void AlphaPaletteClear();

614

void AlphaPaletteEnable(bool enable=true);

615

bool AlphaPaletteIsEnabled();

616

bool AlphaPaletteIsValid();

617

bool AlphaPaletteSplit(CxImage *dest);

618

//@}

619

620

protected:

621

/** \addtogroup Protected */ //@{

622

BYTE BlindAlphaGet(const long x,const long y);

623

//@}

624

#endif //CXIMAGE_SUPPORT_ALPHA

625

626

public:

627

#if CXIMAGE_SUPPORT_LAYERS

628

/** \addtogroup Layers */ //@{

629

bool LayerCreate(long position = -1);

630

bool LayerDelete(long position = -1);

631

void LayerDeleteAll();

632

CxImage* GetLayer(long position);

633

CxImage* GetParent() const;

634

long GetNumLayers() const;

635

//@}

636

#endif //CXIMAGE_SUPPORT_LAYERS

637

638

protected:

639

/** \addtogroup Protected */ //@{

640

void Startup(DWORD imagetype = 0);

641

void CopyInfo(const CxImage &src);

642

void Ghost(CxImage *src);

643

void RGBtoBGR(BYTE *buffer, int length);

644

static float HueToRGB(float n1,float n2, float hue);

645

void Bitfield2RGB(BYTE *src, WORD redmask, WORD greenmask, WORD bluemask, BYTE bpp);

646

static int CompareColors(const void *elem1, const void *elem2);

647

648

void* pDib; //contains the header, the palette, the pixels

649

BITMAPINFOHEADER head; //standard header

650

CXIMAGEINFO info; //extended information

651

BYTE* pSelection; //selected region

652

BYTE* pAlpha; //alpha channel

653

CxImage** pLayers; //generic layers

654

//@}

655

};

656

657

////////////////////////////////////////////////////////////////////////////

658

#endif // !defined(__CXIMAGE_H)

Older »