/**
* \return Returns the weights for the covariance of the points as a vector
*/
WeightVector covariance_weights_vector() const noexcept
{
const int point_count = count_points();
WeightVector weight_vec(point_count);
for (int i = 0; i < point_count; ++i)
{
weight_vec(i) = weights_(i).w_cov;
}
return weight_vec;
}
/**
* Resizes a dynamic-size PointSet
*
* \param Points_ Number of points
*
* \throws ResizingFixedSizeEntityException
*/
void resize(int dim, int points_count)
{
if (dim == dimension() && points_count == count_points()) return;
points_.setZero(dim, points_count);
weights_.resize(points_count, 1);
const double weight = (points_count > 0)? 1. / double(points_count) : 0;
for (int i = 0; i < points_count; ++i)
{
weights_(i).w_mean = weight;
weights_(i).w_cov = weight;
}
}
int *place_token(t_filler *fil)
{
int i;
int j;
i = 0;
fil->min = INT_MAX;
while (i <= fil->map_h - fil->token_h)
{
j = 0;
while (j <= fil->map_w - fil->token_w)
{
if (check_spot(fil, i, j) && count_points(fil, i, j))
{
fil->i = i;
fil->j = j;
}
j++;
}
i++;
}
return (0);
}
/* Given a brushstroke, draw it onto the surface at the specified
* position and zoom level.
*/
void icCanvasManager::GL::Renderer::draw_stroke(icCanvasManager::RefPtr<icCanvasManager::BrushStroke> br) {
GLuint strokeInfoTex[4];
this->ex->glGenTextures(4, strokeInfoTex);
//Pull the brushstroke information out into a texture.
size_t strokeTexSize = br->_curve.count_points() * 4 * 2; //Number of texels
int32_t *strokeTexMem = (int32_t*)malloc(strokeTexSize * 4 * sizeof(int32_t)); //Actual texture memory
for (int i = 0; i < br->_curve.count_points(); i++) { //Forall polynomials
for (int j = 0; j < 4; j++) { //Forall control points
int base_component = i * 4 * 2 * 4 + j * 2 * 4;
auto &cpt = br->_curve.get_point(i, j);
strokeTexMem[base_component] = cpt.x;
strokeTexMem[base_component + 1] = cpt.y;
strokeTexMem[base_component + 2] = cpt.dx;
strokeTexMem[base_component + 3] = cpt.dy;
strokeTexMem[base_component + 4] = cpt.tilt;
strokeTexMem[base_component + 5] = cpt.angle;
strokeTexMem[base_component + 6] = cpt.pressure;
strokeTexMem[base_component + 7] = 0;
}
}
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[0]);
this->ex->glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32I, strokeTexSize, 0, GL_RGBA_INTEGER, GL_INT, (GLvoid*)strokeTexMem);
//Pull the derivative stroke information into a texture.
auto curveDeriv = br->_curve.derivative();
size_t strokeDerivTexSize = curveDeriv.count_points() * 3 * 2; //Number of texels
int32_t *strokeDerivTexMem = (int32_t*)malloc(strokeDerivTexSize * 4 * sizeof(int32_t)); //Actual texture memory
for (int i = 0; i < curveDeriv.count_points(); i++) { //Forall polynomials
for (int j = 0; j < 3; j++) { //Forall control points
int base_component = i * 3 * 2 * 4 + j * 2 * 4;
auto &cpt = curveDeriv.get_point(i, j);
strokeDerivTexMem[base_component] = cpt.x;
strokeDerivTexMem[base_component + 1] = cpt.y;
strokeDerivTexMem[base_component + 2] = cpt.dx;
strokeDerivTexMem[base_component + 3] = cpt.dy;
strokeDerivTexMem[base_component + 4] = cpt.tilt;
strokeDerivTexMem[base_component + 5] = cpt.angle;
strokeDerivTexMem[base_component + 6] = cpt.pressure;
strokeDerivTexMem[base_component + 7] = 0;
}
}
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[1]);
this->ex->glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32I, strokeDerivTexSize, 0, GL_RGBA_INTEGER, GL_INT, (GLvoid*)strokeDerivTexMem);
//TODO: Actually free texture memory. This is an obvious leak.
size_t polynomTexSize = curveDeriv.count_points();
float *polynomTexMem = (float*)malloc(polynomTexSize * 4 * sizeof(float)); //Actual texture memory
//We also need to calculate memory size for the LUT in this pass
float pixelInterval = 5.0 / this->xscale;
float totalLength = 0;
size_t lutSize = 0;
for (int i = 0; i < curveDeriv.count_points(); i++) {
polynomTexMem[i * 4] = this->curve_arc_length(i, curveDeriv);
totalLength += polynomTexMem[i * 4];
lutSize += (int)std::ceil(polynomTexMem[i * 4] / pixelInterval);
}
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[2]);
this->ex->glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA32F, polynomTexSize, 0, GL_RGBA, GL_FLOAT, (GLvoid*)polynomTexMem);
//Compute a linearized beizer curve look-up table to avoid
//expensive in-shader linearization.
std::cout << "GL: Allocating " << lutSize << " floats!" << std::endl;
float* lutMemory = (float*)malloc(lutSize * sizeof(float));
float* curLutMemory = lutMemory;
for (int i = 0; i < curveDeriv.count_points(); i++) {
int currentLutSize = (int)std::ceil(polynomTexMem[i * 4] / pixelInterval);
this->compute_linear_LUT(i, br->_curve, curveDeriv, curLutMemory, currentLutSize, pixelInterval);
curLutMemory += currentLutSize;
}
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[3]);
this->ex->glTexImage1D(GL_TEXTURE_1D, 0, GL_R32F, lutSize, 0, GL_RED, GL_FLOAT, (GLvoid*)lutMemory);
//Set up the "raymarch" quad so we can raster over the whole tile.
this->ex->glBindVertexArray(this->raymarchGeom);
//Set up our framebuffer target.
this->ex->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, this->renderTarget);
//Set up our shader program.
this->ex->glUseProgram(this->dProgram);
//Set up per-stroke uniforms.
GLint splineDataLoc, splineDerivativeDataLoc, polynomDataLoc, tintOpacityLoc, brushSizeLoc, lutDataLoc;
splineDataLoc = this->ex->glGetUniformLocation(this->dProgram, "splineData");
splineDerivativeDataLoc = this->ex->glGetUniformLocation(this->dProgram, "splineDerivativeData");
polynomDataLoc = this->ex->glGetUniformLocation(this->dProgram, "polynomData");
lutDataLoc = this->ex->glGetUniformLocation(this->dProgram, "lutData");
tintOpacityLoc = this->ex->glGetUniformLocation(this->dProgram, "tintOpacity");
brushSizeLoc = this->ex->glGetUniformLocation(this->dProgram, "brushSize");
if (splineDataLoc != -1) {
this->ex->glUniform1i(splineDataLoc, 0);
this->ex->glActiveTexture(GL_TEXTURE0 + 0);
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[0]);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
}
if (splineDerivativeDataLoc != -1) {
this->ex->glUniform1i(splineDerivativeDataLoc, 1);
this->ex->glActiveTexture(GL_TEXTURE0 + 1);
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[1]);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
}
if (polynomDataLoc != -1) {
this->ex->glUniform1i(polynomDataLoc, 2);
this->ex->glActiveTexture(GL_TEXTURE0 + 2);
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[2]);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
}
if (lutDataLoc != -1) {
this->ex->glUniform1i(lutDataLoc, 3);
this->ex->glActiveTexture(GL_TEXTURE0 + 3);
this->ex->glBindTexture(GL_TEXTURE_1D, strokeInfoTex[3]);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER, GL_NEAREST);
this->ex->glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
}
if (tintOpacityLoc != -1) {
auto premulR = ((float)br->_tint_color_red / icCanvasManager::BrushStroke::COLOR_MAX) * ((float)br->_tint_alpha / icCanvasManager::BrushStroke::COLOR_MAX);
auto premulG = ((float)br->_tint_color_green / icCanvasManager::BrushStroke::COLOR_MAX) * ((float)br->_tint_alpha / icCanvasManager::BrushStroke::COLOR_MAX);
auto premulB = ((float)br->_tint_color_blue / icCanvasManager::BrushStroke::COLOR_MAX) * ((float)br->_tint_alpha / icCanvasManager::BrushStroke::COLOR_MAX);
auto premulA = ((float)br->_tint_alpha / icCanvasManager::BrushStroke::COLOR_MAX);
this->ex->glUniform4f(tintOpacityLoc, premulR, premulG, premulB, premulA);
}
if (brushSizeLoc != -1) {
this->ex->glUniform1i(brushSizeLoc, br->_base_thickness);
}
//Enable transparency
this->ex->glEnable(GL_BLEND);
this->ex->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
this->ex->glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
//Cleanup some GL state.
this->ex->glDisable(GL_BLEND);
this->ex->glBindVertexArray(0);
this->ex->glActiveTexture(GL_TEXTURE0);
this->ex->glUseProgram(0);
this->ex->glBindTexture(GL_TEXTURE_1D, 0);
this->ex->glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
this->ex->glDeleteTextures(4, strokeInfoTex);
auto error = this->ex->glGetError();
assert(error == GL_NO_ERROR);
};
/**
* Sets the new dimension for dynamic-size points (not to confuse
* with the number of points)
*
* \param dim Dimension of each point
*/
void dimension(int dim)
{
points_.resize(dim, count_points());
}
int main(int argc,char *argv[]) {
Matrix *C1, *P1;
Polyhedron *C, *P, *S;
Polyhedron *CC, *PP;
Enumeration *en;
Value *p;
int i,j,k;
int m,M;
char str[1024];
Value c;
/******* Read the input *********/
P1 = Matrix_Read();
C1 = Matrix_Read();
if(C1->NbColumns < 2) {
fprintf(stderr,"Not enough parameters !\n");
exit(0);
}
P = Constraints2Polyhedron(P1, MAXRAYS);
C = Constraints2Polyhedron(C1, MAXRAYS);
Matrix_Free(C1);
Matrix_Free(P1);
/******* Compute the true context *******/
CC = align_context(C,P->Dimension,MAXRAYS);
PP = DomainIntersection(P,CC,MAXRAYS);
Domain_Free(CC);
C1 = Matrix_Alloc(C->Dimension+1,P->Dimension+1);
for(i=0;i<C1->NbRows;i++)
for(j=0;j<C1->NbColumns;j++)
if(i==j-P->Dimension+C->Dimension)
value_set_si(C1->p[i][j],1);
else
value_set_si(C1->p[i][j],0);
CC = Polyhedron_Image(PP,C1,MAXRAYS);
Domain_Free(C);
Domain_Free(PP);
Matrix_Free(C1);
C = CC;
/******* Initialize parameters *********/
p = (Value *)malloc(sizeof(Value) * (P->Dimension+2));
for(i=0;i<=P->Dimension;i++) {
value_init(p[i]);
value_set_si(p[i],0);
}
value_init(p[i]);
value_set_si(p[i],1);
/*** S = scanning list of polyhedra ***/
S = Polyhedron_Scan(P,C,MAXRAYS);
value_init(c);
/******* Count now *********/
FOREVER {
fflush(stdin);
printf("Enter %d parameters : ",C->Dimension);
for(k=S->Dimension-C->Dimension+1;k<=S->Dimension;++k) {
scanf(" %s", str);
value_read(p[k],str);
}
printf("EP( ");
value_print(stdout,VALUE_FMT,p[S->Dimension-C->Dimension+1]);
for(k=S->Dimension-C->Dimension+2;k<=S->Dimension;++k) {
printf(", ");
value_print(stdout,VALUE_FMT,p[k]);
}
printf(" ) = ");
count_points(1,S,p,&c);
value_print(stdout,VALUE_FMT,c);
printf("\n");
}
for(i=0;i<=(P->Dimension+1);i++)
value_clear(p[i]);
value_clear(c);
return(0);
} /* main */
