value = (Math.Pow(value / 65535, 1 / gamma) * 65535) + 0.5;

double value = i * 256;

value = (Math.Pow(value / 65535, gamma) * 65535) + 0.5;

-Software to generate the required colours for use during the calibration. This will 
be a program that allows the user to adjust the colour DAC values from 0 to 255 
in each of Red, Green and Blue.
- Software to calculate the transformation between RGB and CIE x, y, L values. 
(This software is part of the Presentation Library.)

Quote:

After unsuccessfully trying to solve for a mathematical solution for a week I had to try some other way to derive the Gamma Ramp Settings directly from the GetDeviceGammaRamp call.

One early attempt involved a simple iteration of all possible settings. This gave correct results, but it took more than 20 minutes to complete the operation. My application needs to be able to do this in under a second.

I finally found a better, more efficient way to perform the iterations, and it meets my requirements. It may be an imperfect solution; but a win is a win.

I shaved a little more time off of this operation by testing for a positive or a negative curve in the Gamma setting (or no curve at all = neutral setting 10). This saves a few iterations going in. To do this I created two additional functions: PtToPtRngBrg and GetPtFromPt.

If you like, you can skip these; and simply iterate through all possible Gamma settings (2 to 50). This would greatly simplify the code.

Here is my C++ solution...

//---------------------------------------------------------------------------
#define DEG_RAD 0.017453292519943295769236907684886
//---------------------------------------------------------------------------
struct RngBrg{  //Struct for return values in the
   double rng;  //call to PtToPtRngBrg
   double brg;
};
//---------------------------------------------------------------------------
void __fastcall TForm1::GetGammaRampSettings(void){
   // level should be between 2 and 100
   // gamma should be between 2 and 50
   // brigntess should be between 0 and 100
   // contrast should be between 0 and 100

   double i,j,k,m,m4;
   double s1,s2,s3,s4;
   double gamma,bright,cntrst,level;
   double value;
   int d;
   int x1,x2,x3,x4;
   bool isFound=false;
   RngBrg rb; //Range and Bearing struct for distance and vector

   WORD GammaArray[3][256]; //Gamma Ramp Array buffer
   WORD CompArray[256];     //Array buffer for comparison
   double DArray[256];      //buffer used to hold gamma values

   HDC GammaDC = GetDC( NULL );  //fetch the gamma ramp array
   GetDeviceGammaRamp( GammaDC, GammaArray );
   ReleaseDC( NULL, GammaDC );

   //Calculate the Angle:

   //Find two endpoints for the GammaArray
   for( x1 = 0; x1 < 256; x1++ ){
      if( GammaArray[0][x1] > 0){break;}
   }

   for( x2 = 0; x2 < 256; x2++ ){
      if( GammaArray[0][x2] == 65535){isFound=true; break;}
   }
   if( !isFound ){ x2--; }

   //normalize the gama ramp numbers
   //so that a distance and vector can be calculated
   s1 = ( (double) GammaArray[0][x1] + 1 ) / 256.0;
   s2 = ( (double) GammaArray[0][x2] + 1 ) / 256.0;

   //find the mid point array element from the line described above...
   x3 = x1 + ( ( x2 - x1 ) / 2 );
   s3 = ( (double) GammaArray[0][x3] + 1 ) / 256.0;

   Memo1->Lines->Add( "x1 = " + IntToStr(x1) + "  s1 = " + AnsiString(s1));
   Memo1->Lines->Add( "x2 = " + IntToStr(x2) + "  s2 = " + AnsiString(s2));
   Memo1->Lines->Add( "x3 = " + IntToStr(x3) + "  s3 = " + AnsiString(s3));

   //caculate the strait line between
   //the two endpoints discovered above
   PtToPtRngBrg( &rb, x1, s1, x2, s2 );

   //neutral settings are as follows...
   //Bright = 50
   //Contrast = 50
   //Level = 50
   //Gamma = 10
   //rng = 359.210244842766 and  brg = 45 with all neutral settings
   Memo1->Lines->Add( "rng = " + AnsiString( rb.rng ) +
                      "  brg = " + AnsiString( rb.brg ));

   //what would be the value of the midpoint
   //if it were a strait line (neutral gamma setting)?

   GetPtFromPt(x1, s1, rb.rng / 2.0, rb.brg, &m4, &s4);

   Memo1->Lines->Add("m4 = " + IntToStr( Round(m4) ) + "  s4=" + AnsiString(s4));
   Memo1->Lines->Add("s3 - s4 = " + AnsiString( s3-s4 ));

   x4 = Round(m4); //Rounding function call

   if(( s4 - s3 ) > 1 ){//we have a negative gamma curve (G<10)
      Memo1->Lines->Add("Negative Gamma Curve");
      for( i = 9; i > 1; i-- ){
         gamma=i/10;
         for( d = 0; d < 256; d++ ){
            DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
         }
         for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
            level = 1 + ((j - 50) / 100);
            for( k = 0; k < 101; k++ ){//bright
               bright = 1 + (((k - 50) / 100) * 65535);
               for( m = 0; m < 101; m++ ){//contrast
                  cntrst = 1 + ((m - 50) / 100);
                  //Test only the mid-line value at first
                  //To see if a complete comparison is warranted
                  value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
                  value = value += bright;
                  value *= level;
                  if( value > 65535){ value = 65535; }
                  if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                     for( d = 0; d < 256; d++ ){
                        value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                        value = value += bright;
                        value *= level;
                        if( value > 65535 ){ value = 65535;}
                        if( value < 0 ){ value = 0;}
                        CompArray[d] = (WORD) value;
                     }
                     if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                        goto ENDIT;
                     }
                  }
               }
            }
         }
      }
   }else if((s3-s4)>1){//we have a positive gamma curve(G>10)
      Memo1->Lines->Add("Positive Gamma Curve");
      for( i = 11; i < 51; i++ ){
         gamma=i/10;
         for( d = 0; d < 256; d++ ){
            DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
         }
         for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
            level = 1 + ((j - 50) / 100);
            for( k = 0; k < 101; k++ ){//bright
               bright = 1 + (((k - 50) / 100) * 65535);
               for( m = 0; m < 101; m++ ){//contrast
                  cntrst = 1 + ((m - 50) / 100);
                  //Test only the mid-line value at first
                  //To see if a complete comparison is warranted
                  value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
                  value = value += bright;
                  value *= level;
                  if( value > 65535){ value = 65535; }
                  if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                     for( d = 0; d < 256; d++ ){
                        value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                        value = value += bright;
                        value *= level;
                        if( value > 65535 ){ value = 65535;}
                        if( value < 0 ){ value = 0;}
                        CompArray[d] = (WORD) value;
                     }
                     if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                        goto ENDIT;
                     }
                  }
               }
            }
         }
      }

   }else{//no gamma curve (G=10)
      Memo1->Lines->Add("No Gamma Curve");
      i=10;
      gamma=1;  //same as 10 / 10
      for( d = 0; d < 256; d++ ){
         DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      }
      for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
         level = 1 + ((j - 50) / 100);
         for( k = 0; k < 101; k++ ){//bright
            bright = 1 + (((k - 50) / 100) * 65535);
            for( m = 0; m < 101; m++ ){//contrast
               cntrst = 1 + ((m - 50) / 100);
               //Test only the mid-line value at first
               //To see if a complete comparison is warranted
               value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               value = value += bright;
               value *= level;
               if( value > 65535){ value = 65535; }
               if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                  for( d = 0; d < 256; d++ ){
                     value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                     value = value += bright;
                     value *= level;
                     if( value > 65535 ){ value = 65535;}
                     if( value < 0 ){ value = 0;}
                     CompArray[d] = (WORD)value;
                  }
                  if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                     goto ENDIT;
                  }
               }
            }
         }
      }
   }

   Memo1->Lines->Add("Values NOT Discovered - Checking All Values...");

   //if for any reason we did not find a match, reiterate through
   //all possible gamma settings...

   for(i=2;i<51;i++){
      gamma=i/10;
      for( d = 0; d < 256; d++ ){
         DArray[d] = ( pow( (double)(d * 256) / 65535, 1 / gamma) * 65535) + 0.5;
      }
      for( j = 2; j < 101 ; j++ ){//level    //980,000 possible iterations
         level = 1 + ((j - 50) / 100);
         for( k = 0; k < 101; k++ ){//bright
            bright = 1 + (((k - 50) / 100) * 65535);
            for( m = 0; m < 101; m++ ){//contrast
               cntrst = 1 + ((m - 50) / 100);
               //Test only the mid-line value at first
               //To see if a complete comparison is warranted
               value = (((( DArray[x4] / 65535 ) - 0.5) * cntrst) + 0.5) * 65535;
               value = value += bright;
               value *= level;
               if( value > 65535){ value = 65535; }
               if( value < 0 ){ value = 0; }
		            if( (WORD) value == GammaArray[0][x4] ){
                  for( d = 0; d < 256; d++ ){
                     value = ((( (DArray[d] / 65535) - 0.5) * cntrst) + 0.5) * 65535;
                     value = value += bright;
                     value *= level;
                     if( value > 65535 ){ value = 65535;}
                     if( value < 0 ){ value = 0;}
                     CompArray[d] = (WORD) value;
                  }
                  if(memcmp( &CompArray[0], &GammaArray[0][0], 2*256) == 0){
                     goto ENDIT;
                  }
               }
            }
         }
      }
   }

   Memo1->Lines->Add("Values Still NOT Discovered!!!");
   Memo1->Lines->Add("Discovery Operation Failed.");
   return;

   ENDIT:

   Memo1->Lines->Add("Bright = " + IntToStr((int)k));
   Memo1->Lines->Add("Cntrst = " + IntToStr((int)m));
   Memo1->Lines->Add("Level = " + IntToStr((int)j));
   Memo1->Lines->Add("Gamma = " + IntToStr((int)i));
}
//---------------------------------------------------------------------------
short __fastcall TForm1::Round(double flt){
   short num=(short)flt;
   if(flt>=0){
      if(flt-num>=.5){num++;}
   }else{
      if(flt-num<=-.5){num--;}
   }
   return(num);
}
//----------------------------------------------------------------------------
bool __fastcall TForm1::PtToPtRngBrg(RngBrg *rb,double x1,double y1,double x2,double y2){//was PixToPixRngBrg
   rb->rng=0;rb->brg=0;
   //range is in pixels
   double diffx,diffy,dangle;
   if(x1>=x2){
      if(x1>=0&&x2<0){diffx=x1+fabs(x2);}else{diffx=x1-x2;}
   }else{
      if(x2>=0&&x1<0){diffx=x2+fabs(x1);}else{diffx=x2-x1;}
   }
   if(y1>=y2){
      if(y1>=0&&y2<0){diffy=y1+fabs(y2);}else{diffy=y1-y2;}
   }else{
      if(y2>=0&&y1<0){diffy=y2+fabs(y1);}else{diffy=y2-y1;}
   }

   if(diffx==0){
      rb->brg=0;rb->rng=y2-y1;
      return true;
   }
   if(diffy==0){
      rb->brg=90;rb->rng=x2-x1;
      return true;
   }
   dangle=atan(diffy/diffx);
   rb->rng=diffx/cos(dangle);//hyp
   dangle=dangle/DEG_RAD;
   rb->brg=90-dangle;
   return true;
}
//-----------------------------------------------------------------------
void __fastcall TForm1::GetPtFromPt(double x, double y,double rng,double brg,double *x2,double *y2){
   //Gets a pix(coord) from a pix (coord)
   //range is in absolute pixels
   if(brg>=360){brg-=360;}
   if(brg<0){brg+=360;}
   if(brg==360||brg==0){*x2=x;*y2=y+rng;return;}
   if(brg==270){*y2=y;*x2=x-rng;return;}
   if(brg==90){*y2=y;*x2=x+rng;return;}
   if(brg==180){*x2=x;*y2=y-rng;return;}

   if(brg<90){
      *x2=x+(rng*cos((90-brg)*DEG_RAD));
      *y2=y+(rng*sin((90-brg)*DEG_RAD));
      return;
   }
}
//---------------------------------------------------------------------------

Bram van Kampen wrote:

Is this a Feature of the Windows Print Spooler, or, a Feature of 'MS Office'?

     Finding Old Orders in the Shop     
Printed by <????> on 01 09 16 - 23:40:14

Customer:-                              
TONY LOUGHLIN                           

If The Item(s) are Found you should     
Update the Computer Record, and         
Destroy this Page!                      
Otherwise Inform Management of the      
Discrepancies, by Returning this Page   
Marked Up Accordingly!                  

Order Nr 214058                         

Received on: 27/07/12 - 13:18:21        

Not Confirmed Present since Completion  

  Qty  Description                Amount
    1  lb Wash +Dry               £11.00
                                ========
       Total For Order            £11.00
       Due for This Order         £11.00

Packaging:- -1Wb                        

========================================

<pre>
        Actually Found:-            

Bram van Kampen wrote:

The XPS File I got was,in Binary.

///////////////////////////////////////////////////////////////////////////////////
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
//
// PRINTING!!
///////////////////////////////////////////////////////////////////////////////////

// OnClick the Print Button
void CConfirmOrdersStep1Dlg::OnPrint() 
{
    if(CreateViewForPrinting()==false){
        AfxMessageBox("No Orders have been Marked for Printing");
        return;
    }
    CDC dc;
    CPrintDialog printDlg(FALSE);

<pre>
if (printDlg.DoModal() == IDCANCEL)     // Get printer settings from user
    return;

dc.Attach(printDlg.GetPrinterDC());     // Get and attach a printer DC
dc.m_bPrinting = TRUE;

CString strTitle="Old Orders";                       // Get the application title
//strTitle.LoadString(AFX_IDS_APP_TITLE);

DOCINFO di;                             // Initialise print document details
memset(&di, 0,sizeof (DOCINFO));
di.cbSize = sizeof (DOCINFO);
di.lpszDocName = strTitle;

BOOL bPrintingOK = dc.StartDoc(&di);    // Begin a new print job

// Get the printing extents and store in the m_rectDraw field of a 
// CPrintInfo object
CPrintInfo Info;
Info.m_rectDraw.SetRect(0,0, 
                        dc.GetDeviceCaps(HORZRES), 
                        dc.GetDeviceCaps(VERTRES));

OnBeginPrinting(&dc, &Info);            // Call your "Init printing" function

// Now, Print every Page!
UINT page;
for (page=Info.GetMinPage(); page <= Info.GetMaxPage() && bPrintingOK;page++){

    dc.StartPage();                     // begin new page
    Info.m_nCurPage = page;
    PrintPage(&dc, &Info);                // Call your "Print page" function
    bPrintingOK = (dc.EndPage() > 0);   // end page
}
OnEndPrinting(&dc, &Info);              // Call your "Clean up" function

if (bPrintingOK)
    dc.EndDoc();                        // end a print job
else
    dc.AbortDoc();                      // abort job.

dc.DeleteDC();                          // delete the printer DC    

if(!PrinterFont.CreatePointFont( 
    100,                     //int nPointSize*10, 
    "Courier New",      //LPCTSTR lpszFaceName, 
    pDC)){              //CDC* pDC = NULL 
    ASSERT(NULL);
    return;
}

// Here we have m_pPageList, a poiner to a CPageList Object
// the First Entry is a Header, detailing the Customer,
// The Next Entries contain Order Bodies, complete with
// Totals and Check Boxes!
// We can find out how high each Line Rectangle is.
CSize Size=pDC->GetTextExtent("AAAA",4);

// We Print 40 Wide in a Fixed Pitch Font!
m_nCurrentPrintRectWidth=Size.cx*10;

m_nCurrentLineHeight=Size.cy;

// We know the size of the Print Rectangle, so, we can
// Calculate the number of Lines per Page.

int PageHeight=pInfo->m_rectDraw.Height();
m_nLinesPerPage=PageHeight/m_nCurrentLineHeight;

// Next, we calculate the Number of Pages required, taking
// into Consideration, that Each Page accomodates the Header 
// Page, and a One Line Footer: Page %i of %i.
// We Modify m_pPageList, so that Each Entry, Except the First
// (Header) entry, represents a Printable Page!

// We try to fit as many orders as possible on a single print page.
// we Need to do a Lorry Loading Calculation.

m_pView->CondensePages(m_nLinesPerPage);

COrderPageView* pView=(COrderPageView*)m_pView->GetDataFromIndex(0);
PrintDocFragment(pView,pDC);
COrderPageView* pOrder=(COrderPageView*)m_pView->GetDataFromIndex(PageNumber);
PrintDocFragment(pOrder,pDC);

// Do as Little as Possibe Here
// We have to de-select the CFont object, and delete it.

ifdef _DEBUG

m_pView->DumpToTextFile();

endif

return true;

Bram van Kampen wrote:

The Binary I get refuses to open.

PK   µC'I               Metadata/Job_PT.xmlíW]s¢H}ߪý)Þ' &Ùh%NÝ4ZÁØ }Cè`|
´¢óë÷¶ã̬‰™™§éòš{Îážþ¸póqGgK–<Mn•Ê¹¦œ±ÄOž„·Š3l¸V>6ÿþë&+žƒœ'bÈý9gKŠöÞ*3!²†ªþŒÅ^qs?O‹ôIœûi¬–<	Ò²P«šVSµk5"H¾=Øbžr/fešÏ•íªà{Ú²,ÏËÚyš‡’£¢>š÷öõ'…🽠‚·QÊA²ÏÀ¤Ð°žÈ•ŠŸÿJdÎÖ˜FP¨{è*