int main()
{
int m[5][5];
int i,j, k=1;
for (j=0; j<5; j++)
for (i=0; i<5; i++)
{
m[j][i] = k++;
}
m[3][3] = 0;
m[2][1] = 0;
print(m);
FillUp(m,5);
print(m);
return 0;
}
static PrinterInfo* GetPrinterInfo(const char* printer_name)
{
FILE *fp = NULL;
char buff[MAXWORDSIZE], *ptr = NULL, *tmp = NULL;
char* lib_name = NULL, *lib_version = NULL;
int lib_len = 0;
gboolean find_lang = FALSE;
const char* ppd_file = NULL;
int printer_type = PRINTER_TYPE_OTHER;
ppd_file = cupsGetPPD(printer_name);
if(NULL == ppd_file){
return NULL;
}
fp = fopen(ppd_file, "r");
if(NULL == fp){
return NULL;
}else{
while((fgets(buff, MAXWORDSIZE, fp)) != NULL){
ptr = FillUp(buff);
tmp = ChkMainKey(ptr, PRINT_LANG, strlen(PRINT_LANG));
if(tmp != NULL){
if(strstr(tmp, "LIPS4") != NULL){
printer_type = PRINTER_TYPE_LIPS;
}else if(strstr(tmp, "PS3") != NULL){
printer_type = PRINTER_TYPE_PS;
}else if(strstr(tmp, "UFR2") != NULL){
printer_type = PRINTER_TYPE_UFR2;
}else if(strstr(tmp, "CAPT") != NULL){
printer_type = PRINTER_TYPE_CAPT;
}
find_lang = TRUE;
}else{
tmp = ChkMainKey(ptr, PRINT_LIB_NAME, strlen(PRINT_LIB_NAME));
if(tmp != NULL){
SetLibInfo(tmp, &lib_name);
}else{
tmp = ChkMainKey(ptr, PRINT_LIB_NAME_VER, strlen(PRINT_LIB_NAME_VER));
if(tmp != NULL){
SetLibInfo(tmp, &lib_version);
}
}
}
if((TRUE == find_lang) && (lib_name != NULL) && (lib_version != NULL)){
break;
}
}
}
fclose(fp);
unlink(ppd_file);
if(NULL == lib_name || NULL == lib_version){
if(lib_name != NULL){
free(lib_name);
lib_name = NULL;
}
if(lib_version != NULL){
free(lib_version);
lib_version = NULL;
}
return NULL;
}
PrinterInfo* info = (PrinterInfo*)malloc(sizeof(PrinterInfo));
if(NULL == info){
if(lib_name != NULL){
free(lib_name);
lib_name = NULL;
}
if(lib_version != NULL){
free(lib_version);
lib_version = NULL;
}
return NULL;
}
memset(info, 0, sizeof(PrinterInfo));
info->name = strdup(printer_name);
lib_len = strlen(LIB_PREFIX)+ strlen(lib_name) + strlen(LIB_SUFFIX) + strlen(SEPERATOR) + strlen(lib_version) + 1;
info->lib = (char*)malloc(lib_len);
memset(info->lib, 0, lib_len);
strcat(info->lib, LIB_PREFIX);
strcat(info->lib, lib_name);
strcat(info->lib, LIB_SUFFIX);
strcat(info->lib, SEPERATOR);
strcat(info->lib, lib_version);
free(lib_version);
free(lib_name);
info->type = printer_type;
return info;
}
void CInfiniteAmortizedNoise3D::initEdgeTables(const int x0, const int y0, const int z0, const int n){
//compute gradients at corner points
float b0 = h1(x0, y0, z0), b1 = h1(x0, y0+1, z0 ),
b2 = h1(x0+1, y0, z0), b3 = h1(x0+1, y0+1, z0 ),
b4 = h1(x0, y0, z0+1), b5 = h1(x0, y0+1, z0+1),
b6 = h1(x0+1, y0, z0+1), b7 = h1(x0+1, y0+1, z0+1),
b8 = h2(x0, y0, z0), b9 = h2(x0, y0+1, z0 ),
b10 = h2(x0+1, y0, z0), b11 = h2(x0+1, y0+1, z0 ),
b12 = h2(x0, y0, z0+1), b13 = h2(x0, y0+1, z0+1),
b14 = h2(x0+1, y0, z0+1), b15 = h2(x0+1, y0+1, z0+1);
//fill inferred gradient tables from corner gradients
FillUp(uax, sinf(b0)*sinf(b8), n); FillDn(vax, sinf(b4)*sinf(b12), n);
FillUp(ubx, sinf(b1)*sinf(b9), n); FillDn(vbx, sinf(b5)*sinf(b13), n);
FillUp(uay, -sinf(b0)*cosf(b8), n); FillUp(vay, -sinf(b4)*cosf(b12), n);
FillDn(uby, -sinf(b1)*cosf(b9), n); FillDn(vby, -sinf(b5)*cosf(b13), n);
FillUp(uaz, cosf(b0), n); FillUp(vaz, cosf(b4), n);
FillUp(ubz, cosf(b1), n); FillUp(vbz, cosf(b5), n);
FillUp(ucx, sinf(b2)*sinf(b10), n); FillDn(vcx, sinf(b6)*sinf(b14), n);
FillUp(udx, sinf(b3)*sinf(b11), n); FillDn(vdx, sinf(b7)*sinf(b15), n);
FillUp(ucy, -sinf(b2)*cosf(b10), n); FillUp(vcy, -sinf(b6)*cosf(b14), n);
FillDn(udy, -sinf(b3)*cosf(b11), n); FillDn(vdy, -sinf(b7)*cosf(b15), n);
FillDn(ucz, cosf(b2), n); FillDn(vcz, cosf(b6), n);
FillDn(udz, cosf(b3), n); FillDn(vdz, cosf(b7), n);
} //initEdgeTables
static INT ClipPolygon (COORD_POINT *in, INT nin,
SHORT_POINT *out, INT *nout)
{
INT i,FillupStart,side1,side2,FirstSide,reject,flag,left,leftmark,right,rightmark,orientation;
SHORT_POINT out1,out2;
COORD_POINT point[3];
DOUBLE norm, lambda, ScalarPrd;
/* initializations */
*nout = 0;
/* check if polygon is degenerated */
if (nin<3) return (0);
/* decide whether polygon is left or right handed */
left = right = orientation = 0;
for (i=0; i<nin; i++)
{
if (((in[i].x-in[(i-1+nin)%nin].x)*(in[(i+1)%(nin)].y-in[i].y)) >=
((in[i].y-in[(i-1+nin)%nin].y)*(in[(i+1)%(nin)].x-in[i].x)))
left++;
else
leftmark = i;
if (((in[i].x-in[(i-1+nin)%nin].x)*(in[(i+1)%(nin)].y-in[i].y)) <=
((in[i].y-in[(i-1+nin)%nin].y)*(in[(i+1)%(nin)].x-in[i].x)))
right++;
else
rightmark = i;
}
if (left == nin)
orientation = CLOCKWISE;
else if (right == nin)
orientation = COUNTERCLOCKWISE;
else if (left == nin-1)
{
SubtractCoordPoint(in[leftmark],in[(leftmark-1+nin)%nin],&(point[0]));
SubtractCoordPoint(in[(leftmark+1)%nin],in[(leftmark-1+nin)%nin],&(point[1]));
EuklidNormCoordPoint(point[1],&norm);
ScalarProductCoordPoint(point[0],point[1],&ScalarPrd);
if (norm < SMALL_C)
lambda = 1.0;
else
lambda = ScalarPrd/norm/norm;
LinCombCoordPoint(1.0, in[(leftmark-1+nin)%nin], lambda, point[1], &(point[2]));
SubtractCoordPoint(in[leftmark],point[2],&(point[0]));
EuklidNormCoordPoint(point[0],&norm);
in[leftmark] = point[2];
orientation = CLOCKWISE;
}
else if (right == nin-1)
{
SubtractCoordPoint(in[rightmark],in[(rightmark-1+nin)%nin],&(point[0]));
SubtractCoordPoint(in[(rightmark+1)%nin],in[(rightmark-1+nin)%nin],&(point[1]));
EuklidNormCoordPoint(point[1],&norm);
ScalarProductCoordPoint(point[0],point[1],&ScalarPrd);
if (norm < SMALL_C)
lambda = 1.0;
else
lambda = ScalarPrd/norm/norm;
LinCombCoordPoint(1.0, in[(rightmark-1+nin)%nin], lambda, point[1], &(point[2]));
SubtractCoordPoint(in[rightmark],point[2],&(point[0]));
EuklidNormCoordPoint(point[0],&norm);
in[rightmark] = point[2];
orientation = COUNTERCLOCKWISE;
}
else
return(1);
/* the main loop */
FillupStart = -1;
flag = 0;
for(i=0; i<nin; i++)
{
ClipLine(in[i],in[(i+1)%(nin)],&out1,&out2,&reject,&side1,&side2);
if (!reject)
{
if (flag == 0)
{
FirstSide = side1;
flag = 1;
}
if (FillupStart != -1)
FillUp (FillupStart,side1,orientation,out,nout);
FillupStart = side2;
out[(*nout)++] = out1;
if (side2 != -1)
out[(*nout)++] = out2;
}
}
if (flag && (FirstSide!=-1))
FillUp (FillupStart,FirstSide,orientation,out,nout);
if (!flag)
{
/* test if zero vector is in the interior of the polygon */
if (orientation==1)
{
left = 0;
for (i=0; i<nin; i++)
left += (in[(i+1)%(nin)].x*in[i].y >= in[i].x*in[(i+1)%(nin)].y);
/*if (left == nin)
FillUpTot(out,nout);*/
}
else
{
right = 0;
for (i=0; i<nin; i++)
right += (in[(i+1)%(nin)].x*in[i].y <= in[i].x*in[(i+1)%(nin)].y);
/* if (right == nin)
FillUpTot(out,nout); */
}
}
return (0);
}
