/*
%F Muda o cursor quando ele passa sobre uma juncao de titulos de coluna.
%i h : handle da matriz,
x,y : coordenadas do mouse (coordenadas do canvas).
*/
void iupmatColresChangeCursor(Ihandle *h, int x, int y)
{
Tmat *mat=(Tmat*)matrix_data(h);
int ativo;
char *attr = IupGetAttribute(h,IUP_RESIZEMATRIX);
if (attr)
ativo = !iupStrEqual(attr,IUP_NO);
else
ativo = 0;
if(mat_ht(mat) && y<mat_ht(mat) && ativo)
{
/* Esta na area de tituos de coluna e o modo de resize esta ligado */
int achou=0,width=mat_wt(mat),col;
if(abs(width-x)<TOL)
achou=1; /*titulos de linha */
else
{
for (col=mat_fc(mat);col<=mat_lc(mat)&&!achou;col++)
{
width+=mat_w(mat)[col];
if (abs(width-x) < TOL)
achou = 1;
}
}
if (achou)
iupCpiDefaultSetAttr(mat_self(mat),IUP_CURSOR,IUP_RESIZE_W);
else
setMatrixCursor(mat_self(mat)); /* Esta na area vazia apos a ultima coluna */
}
else
setMatrixCursor(mat_self(mat));
}
/*
%F Muda a largura da coluna interativamente, so muda a linha na tela.
Qando o usuario termina o drag, a funcao iupmatColresFinish e chamada
para realmente mudar a largura da coluna.
%i h : handle da matriz,
x : coordenada x do mouse (coordenadas do canvas).
*/
void iupmatColresMove(Ihandle *h, int x)
{
Tmat *mat=(Tmat*)matrix_data(h);
int y1,y2, charwidth,charheight;
iupdrvGetCharSize(h,&charwidth,&charheight);
/* Se tamanho da coluna ficou muito pequeno, nao muda tamanho da coluna */
if (x < DragColStartPos+charwidth+DECOR_X)
return;
y1 = mat_ht(mat);
y2 = YmaxCanvas(mat);
cdCanvasWriteMode(mat->cdcanvas, CD_XOR);
cdCanvasForeground(mat->cdcanvas, RESIZE_COLOR);
/* Se nao e a primeira vez, retira linha antiga */
if (Lastxpos != -1)
cdCanvasLine(mat->cdcanvas,Lastxpos,INVY(y1),Lastxpos,INVY(y2));
cdCanvasLine(mat->cdcanvas,x,INVY(y1),x,INVY(y2));
Lastxpos = x;
cdCanvasWriteMode(mat->cdcanvas, CD_REPLACE);
}
/*
%F Muda o alihamento dos textos em uma determinada coluna. Redesenha a
coluna se estiver visivel.
%i h : handle da matriz,
col : coluna ater seu alinhamento mudado. col = 1 representa aprimeira
coluna da matriz.
*/
void iupmatSetColAlign (Ihandle *h, int col)
{
Tmat *mat=(Tmat*)matrix_data(h);
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
IsCanvasSet(mat,err);
if(col > mat_nc(mat) || col < 0)
return;
if(!visible || err!=CD_OK)
return;
if(col == 0) /* Alinhamento da coluna de titulos */
{
iupmatDrawLineTitle(h, mat_fl(mat), mat_ll(mat));
}
else
{
col--; /* a celula super. esq. e 1:1 para o usuario, internamente e 0:0 */
/* Se a coluna esta na parte visivel, redesenha a matriz */
if((col >= mat_fc(mat))&&(col <= mat_lc(mat)))
{
iupmatDrawCells(h,mat_fl(mat),col,mat_ll(mat),col);
iupmatShowFocus(h);
}
}
}
LargeGPUMatrixFixtureComplex()
{
std::cout << "LargeGPUMatrixFixtureComplex" << std::endl;
agile::GPUEnvironment::allocateGPU(0);
x_host.resize(NUM_COLUMNS);
y_host.resize(NUM_ROWS);
std::vector<std::complex<float> > matrix_data(NUM_ROWS * NUM_COLUMNS);
for (unsigned counter = 0; counter < NUM_COLUMNS; ++counter)
x_host[counter] = std::complex<float>(float(rand()) / RAND_MAX * 10 - 5,
float(rand()) / RAND_MAX * 10 - 5);
for (unsigned counter = 0; counter < NUM_ROWS; ++counter)
y_host[counter] = std::complex<float>(float(rand()) / RAND_MAX * 10 - 5,
float(rand()) / RAND_MAX * 10 - 5);
for (unsigned row = 0; row < NUM_ROWS; ++row)
for (unsigned column = 0; column < NUM_COLUMNS; ++column)
matrix_data[row * NUM_COLUMNS + column]
= std::complex<float>(float(rand()) / RAND_MAX * 10 - 5,
float(rand()) / RAND_MAX * 10 - 5);
x.assignFromHost(x_host.begin(), x_host.end());
y.assignFromHost(y_host.begin(), y_host.end());
A_host = new agile::CPUMatrix<std::complex<float> >(NUM_ROWS, NUM_COLUMNS,
&matrix_data[0]);
A = new agile::GPUMatrixPitched<std::complex<float> >(NUM_ROWS, NUM_COLUMNS,
&matrix_data[0]);
std::cout << "LargeGPUMatrixFixtureComplex done" << std::endl;
}
/*
%F Funcao chamada para ativar ou desativar uma linha ou coluna da matriz.
%i h - Handle da matriz
mode - Flag que indica se estou operando em linhas ou colunas
[MAT_LIN|MAT_COL]
lincol - Numero da linha ou coluna em questao (formato IUP)
val - Valor do atributo.
*/
void iupmatSetActive(Ihandle *h, int mode, int lincol, char *val)
{
Tmat *mat = (Tmat*)matrix_data(h);
int on = iupStrEqualNoCase(val,"ON") || iupStrEqualNoCase(val,"YES");
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
lincol--;
if (mode == MAT_LIN)
mat_lininactive(mat)[lincol] = !on;
else
mat_colinactive(mat)[lincol] = !on;
IsCanvasSet(mat,err);
if (visible && (err == CD_OK))
{
if(mode == MAT_LIN)
{
iupmatDrawLineTitle(h,lincol,lincol);
iupmatDrawCells(h,lincol,mat_fc(mat),lincol,mat_lc(mat));
}
else
{
iupmatDrawColumnTitle(h,lincol,lincol);
iupmatDrawCells(h,mat_fl(mat),lincol,mat_ll(mat),lincol);
}
}
}
/*
%F Chamada quando da mudanca do titulo de uma linha, redesenha o titulo
se ele for visivel
%i h : handle da matriz,
linha : Linha que teve seu titulo alterado. linha = 1 indica que o
titulo da primeira linha foi alterado. Ja linha = 0 indica que
o titulo da celula que fica no canto entre os titulos de linha
e coluna foi modificado.
*/
void iupmatSetTitleLine(Ihandle *h, int linha)
{
Tmat *mat=(Tmat*)matrix_data(h);
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
if (linha > mat_nl(mat) || linha < 0)
return;
IsCanvasSet(mat,err);
if (visible && err == CD_OK)
{
/* Se e' o titulo do canto, e o canto existe */
if (linha == 0)
{
/* Redesenha o canto entre titulos de linha e coluna
se ele existir
*/
iupmatDrawTitleCorner(h);
}
else
{
linha--;
/* Redesenha o titulo da linha, se ela estiver visivel */
iupmatDrawLineTitle(h,linha,linha);
}
}
}
/*
%F Termina o resize interativo de colunas. Chama a funcao ChangeMatrixWidth para
mudar realmente o tamanho da coluna.
%i h : handle da matriz,
x : coordenada x do mouse (coordenadas do canvas).
*/
void iupmatColresFinish(Ihandle *h, int x)
{
int charwidth,charheight, width;
int y1, y2;
Tmat *mat=(Tmat*)matrix_data(h);
iupdrvGetCharSize(h,&charwidth,&charheight);
width = x - DragColStartPos-DECOR_X;
if (width < charwidth)
width = charwidth ; /* Tamanho minimo para a celula */
/* Apaga feedback */
if (Lastxpos != -1)
{
y1 = mat_ht(mat);
y2 = YmaxCanvas(mat);
cdCanvasWriteMode(mat->cdcanvas,CD_XOR);
cdCanvasForeground(mat->cdcanvas,RESIZE_COLOR);
cdCanvasLine(mat->cdcanvas,Lastxpos,INVY(y1),Lastxpos,INVY(y2));
cdCanvasWriteMode(mat->cdcanvas,CD_REPLACE);
}
ChangeMatrixWH(h,DragCol,width+DECOR_X,MAT_COL);
Dragging = 0;
}
/*
%F Funcao que retorna a coordenada da celula superior esquerda da parte
atualmente visivel da matrix.
%i h - Handle da matriz.
%o Retorna uma string com a coordenada da celula, no formato lin:col
*/
char *iupmatGetOrigin(Ihandle *h)
{
Tmat *mat = (Tmat*)matrix_data(h);
static char val[100];
sprintf(val,"%d:%d",mat_fl(mat)+1,mat_fc(mat)+1);
return val;
}
/*
%F Consulta a celula que contem o focus.
%i h : handle da matriz,
%r string contendo a celula esta com o foco, na forma "%d:%d",
onde o primeiro numero indica a linha e o segundo a coluna. "1:1"
corresponde a celula do canto superior esquerdo.
*/
char *iupmatGetFocusPosition(Ihandle *h)
{
static char cell[100];
Tmat *mat=(Tmat*)matrix_data(h);
if (mat)
sprintf(cell,"%d:%d",mat_lin(mat)+1,mat_col(mat)+1);
else
return NULL;
return cell;
}
/*
%F Verifica se o mouse esta na intersecao entre dois titulos de coluna. Se
estiver inicia o resize.
%i h : handle da matriz,
x,y : coordenadas do mouse (coordenadas do canvas).
%o Retorna 1 se iniciou um resize, 0 caso contrario.
*/
int iupmatColresTry(Ihandle *h, int x, int y)
{
Tmat *mat=(Tmat*)matrix_data(h);
int achou,ativo,width,col;
char *attr;
attr = IupGetAttribute(h,IUP_RESIZEMATRIX);
if (attr)
ativo = !iupStrEqual(attr,IUP_NO);
else
ativo = 0;
if(mat_ht(mat) && y<mat_ht(mat) && ativo)
{
/* Esta na area de titulos de coluna*/
achou = 0;
width = mat_wt(mat);
if (abs(width-x) < TOL)
{
/* Estou na interface entre a coluna de titulos e a primeira coluna */
col = 0;
achou = 1;
DragColStartPos = 0;
}
else
{
/* Procura para ver se estou em outra interface */
DragColStartPos= width;
for (col=mat_fc(mat);col<=mat_lc(mat)&&!achou;col++)
{
width+=mat_w(mat)[col];
if (abs(width-x) < TOL)
achou = 1;
if (!achou)
DragColStartPos= width;
}
}
if (achou)
{
Dragging = 1;
Lastxpos = -1;
DragCol = col-1;
return 1;
}
}
return 0;
}
/*
%F Pega a largura/altura de uma coluna/linha. Os atributos WIDTH e HEIGHT nao
podem ser consultados pois quando a largura/altura da coluna/linha sao
mudados dinamicamente, o valor do atributo fica desatualizado. Alem disso,
nem todas as colunas/linhas tem seu atributo WIDTH/HEIGHT definidos.
(Largura e altura default)
%i h : handle da matriz,
col : coluna/linha que tera seua largura/altura consultada. col = 1 indica
a primeira coluna/linha, col = 0 indica a coluna/linha de titulos.
m : Indica se estou operando sobre linhas(MAT_LIN) ou colunas(MAT_COL).
%o retorna uma string com a largura, ja retorna em valores tipo IUP.
*/
char *iupmatColresGet(Ihandle *h, int col, int m, int pixels)
{
static char width[100];
Tmat *mat = (Tmat*)matrix_data(h);
int w;
Tlincol *p;
if (m == MAT_LIN)
p = &(mat->lin);
else
p = &(mat->col);
if (col > p->num || col < 0)
return NULL;
if (col == 0)
w = p->titlewh;
else
{
col--; /* a celula super. esq. e 1:1 para o usuario, internamente e 0:0 */
w = p->wh[col];
}
if (w)
{
if (pixels)
{
if (m == MAT_COL)
sprintf(width,"%d",(int)(w-DECOR_X));
else
sprintf(width,"%d",(int)(w-DECOR_Y));
}
else
{
int charwidth,charheight;
iupdrvGetCharSize(h,&charwidth,&charheight);
if (m == MAT_COL)
sprintf(width,"%d",(int)((w-DECOR_X)*4/charwidth));
else
sprintf(width,"%d",(int)((w-DECOR_Y)*8/charheight));
}
}
else
strcpy(width,"0");
return width;
}
/*
%F Retorna o valor de uma celula da matriz
%i n : handle da matriz,
lin,col : coordenadas da celula a ser consultada, (1,1) corresponde a
celula do canto superior esquerdo.
%o retorna o valor da celula.
Used only by getattribute method.
*/
char *iupmatGetCell (Ihandle *n, int lin, int col)
{
Tmat *mat = (Tmat*)matrix_data(n);
/* Se a celula nao existe, retorna NULL */
if ((lin < 0) || (col < 0) || (lin > mat_nl(mat)) || (col > mat_nc(mat)))
return NULL;
lin--; /* a celula superior esquerda e´ 1:1 para o usuario, */
col--; /* internamente ela e´ 0:0 */
if (lin==mat_lin(mat) && col==mat_col(mat) && iupCheck(mat_edtdatah(mat), "VISIBLE")==YES)
return iupmatEditGetValue(mat);
else
return iupmatGetCellValue(n,lin,col);
}
void iupmatSetRedrawCell(Ihandle* n, int lin, int col)
{
Tmat *mat = (Tmat*)matrix_data(n);
Ihandle *d = IupGetDialog(n);
int visible = (iupCheck(n,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
IsCanvasSet(mat,err);
if(!visible || err != CD_OK)
return;
if(lin == -1) /* Redesenha uma coluna */
{
iupmatHideFocus(n);
iupmatDrawCells(n,mat_fl(mat),col-1,mat_ll(mat),col-1);
iupmatShowFocus(n);
}
else if(col == -1) /* Redesenha uma linha */
{
iupmatHideFocus(n);
iupmatDrawCells(n,lin-1,mat_fc(mat),lin-1,mat_lc(mat));
iupmatShowFocus(n);
}
else /* Redesenha apenas a celula */
{
/* Se a celula nao existe, retorna NULL */
if((lin < 0) || (col < 0) || (lin > mat_nl(mat)) || (col > mat_nc(mat)))
return;
lin--; /* A celula superior esquerda e 1:1 para o usuario, */
col--; /* Internamente ela e 0:0 */
if(col == -1 && lin == -1) /* Canto de titulo */
iupmatDrawTitleCorner(n);
else if(col == -1) /* Titulo de uma linha */
iupmatDrawLineTitle(n,lin,lin);
else if(lin == -1) /* Titulo de uma coluna */
iupmatDrawColumnTitle(n,col,col);
else if(iupmatIsCellVisible(n,lin,col))
{
iupmatDrawCells(n, lin, col, lin, col);
iupmatShowFocus(n);
}
}
}
/*
%F Muda a largura de uma coluna ou a altura de uma linha, redesenhando se
estiver visivel
%i col : coluna/linha a ter sua largura modificada, Esta funcao trbalha com a
representacao interna para o numero de coluna, ou seja col = 0 e
a primeira coluna, col = -1 e a coluna de titulos. O mesma
representacao e' usada para linhas
largura : largura em pixels da coluna/linha col.
m : Indica se estou atuando sobre uma coluna (MAT_COL) ou linha (MAT_LIN).
*/
static void ChangeMatrixWH(Ihandle *h,int col,int largura, int m)
{
Tmat *mat=(Tmat*)matrix_data(h);
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err,drawmode = m;
Tlincol *p;
if (m == MAT_LIN)
p = &(mat->lin);
else
p = &(mat->col);
IsCanvasSet(mat,err);
if (col != -1) /* col -1 indica largura do titulo */
{
if (largura > p->size) /* largura nao pode ser maior que area util */
largura = p->size;
/* Recalcula espaco total ocupado pelas colunas/linhas */
p->totalwh=p->totalwh - p->wh[col] + largura;
p->wh[col]=largura;
}
else if (p->titlewh > 0) /* so muda tamanho, se ja' existir titulo */
{
if(largura > XmaxCanvas(mat))
largura = XmaxCanvas(mat);
/* Recalcula espaco que sobra para as outras celulas */
p->size=p->size+p->titlewh-largura;
p->titlewh = largura;
drawmode = DRAW_ALL; /* Tenho que redesenhar os titulos de linha/coluna tambem */
}
iupmatGetLastWidth(h,m);
/* Se a coluna/linha esta na parte visivel, redesenha a matriz */
if (((col >= p->first)&&(col <= p->last)) || col==-1)
if (visible && err == CD_OK)
{
SetSb(m);
iupmatDrawMatrix(h,drawmode);
iupmatShowFocus(h);
}
}
/*
%F Chamada quando da mudanca do titulo de uma coluna, redesenha o titulo
se ele for visivel
%i h : handle da matriz,
col : Coluna que teve seu titulo alterado. col = 1 indica que o
titulo da primeira coluna foi alterado
*/
void iupmatSetTitleColumn(Ihandle *h, int col)
{
Tmat *mat =(Tmat*)matrix_data(h);
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
if (col > mat_nc(mat) || col < 1)
return;
col--;
IsCanvasSet(mat,err);
if (visible && err==CD_OK)
{
/* Redesenha o titulo da coluna, se estiver visivel */
iupmatDrawColumnTitle(h,col,col);
}
}
/*
%F Seta o valor de uma celula da matriz, redesenha a celula se
estiver visivel.
%i n : handle da matriz,
lin,col : coordenadas da celula a ser modificada, (1,1) corresponde a
celula do canto superior esquerdo.
v : string com o novo valor da celula.
%o retorna v.
*/
void *iupmatSetCell (Ihandle *n, int lin ,int col, char *v)
{
Tmat *mat = (Tmat*)matrix_data(n);
Ihandle *d = IupGetDialog(n);
int cellvisible;
int visible = (iupCheck(n,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
if (v==NULL)
v="";
IsCanvasSet(mat,err);
/* Se a celula nao existe, retorna NULL */
if ((lin < 1) || (col < 1) || (lin > mat_nl(mat)) || (col > mat_nc(mat)))
return NULL;
lin--; /* a celula superior esquerda e 1:1 para o usuario, */
col--; /* internamente ela e 0:0 */
cellvisible = iupmatIsCellVisible(n,lin,col);
if (mat->valeditcb)
{
mat->valeditcb(n,lin+1,col+1,v);
}
else if (!mat->valcb)
{
iupmatMemAlocCell(mat,lin,col,strlen(v));
strcpy(mat_v(mat)[lin][col].value,v);
}
if (visible && cellvisible && err == CD_OK)
{
iupmatDrawCells(n, lin, col, lin, col);
iupmatShowFocus(n);
}
return v;
}
void iupmatSetRedraw(Ihandle *h, char *value)
{
Tmat *mat = (Tmat*)matrix_data(h);
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
int type=DRAW_ALL;
if (value == NULL)
return;
IsCanvasSet(mat,err);
if (visible && (err == CD_OK))
{
if (value[0] == 'L' || value[0] == 'l')
type = DRAW_LIN;
else if (value[0] == 'C' || value[0] == 'c')
type = DRAW_COL;
if(type != DRAW_ALL)
{
int min=0,max=0;
value++;
if (iupStrToIntInt(value,&min,&max, ':')!=2)
max = min;
if(type==DRAW_LIN)
iupmatDrawCells(h,min-1,mat_fc(mat),max-1,mat_lc(mat));
else
iupmatDrawCells(h,mat_fl(mat),min-1,mat_ll(mat),max-1);
}
else
{
iupmatDrawMatrix(h,DRAW_ALL);
}
iupmatShowFocus(h);
}
}
void colorengine::threadFunc()
{
std::unique_ptr<float> regdata(new float[width_*height_]);
std::vector<float> scalar_constant(3);
scalar_constant.push_back(0);
scalar_constant.push_back(0);
scalar_constant.push_back(0);
_XTIFFInitialize();
rawdata_tiff = TIFFOpen(raw_tiff_path.c_str(), "w");
TIFFSetField(rawdata_tiff, TIFFTAG_NFILTERS, filter_->nfilters());
TIFFSetField(rawdata_tiff, TIFFTAG_NLIGHTS, nlights_);
for (auto filter_index = 0; filter_index < filter_->nfilters(); ++filter_index) {
std::vector<float> cmf = filter_->cmfValues(filter_->wavelengthAtPos(filter_index));
float illuminant = filter_->illuminantValue(filter_->wavelengthAtPos(filter_index));
for (auto xyz_index = 0; xyz_index < 3; ++xyz_index) {
scalar_constant[xyz_index] += cmf[xyz_index] * illuminant;
}
}
int page_index = 0;
for (int filter_index = 0; filter_index < filter_->nfilters(); ++filter_index) {
for (int light_index = 0; light_index < nlights_; ++light_index) {
std::shared_ptr<unsigned short> data = data_queue_.pop();
if (cancel_) {
return;
}
std::unique_ptr<float> floatdata(new float[width_*height_]);
for (auto y = 0; y < height_; ++y) {
for (auto x = 0; x < width_; ++x) {
if (data.get()[y*width_+x] - bias_data.get()[y*width_+x] < 0) {
data.get()[y*width_+x] = 0;
} else {
data.get()[y*width_+x] -= bias_data.get()[y*width_+x];
}
}
}
for (auto y = 0; y < height_; ++y) {
for (auto x = 0; x <width_; ++x) {
if (flat_data[light_index]->filterData(filter_index)[y*width_+x] == 0) {
floatdata.get()[y*width_+x] = 0;
} else {
floatdata.get()[y*width_+x] = (float)data.get()[y*width_+x] / (float)flat_data[light_index]->filterData(filter_index)[y*width_+x];
}
}
}
// subtract bias, divide flat field
cv::Mat floatdatamat(height_, width_, CV_32F, floatdata.get());
// Normalize data to a white reference
std::vector<float> values;
for (auto y = wtpt_rect_.y(); y < wtpt_rect_.y() + wtpt_rect_.size().height(); ++y) {
for (auto x = wtpt_rect_.x(); x < wtpt_rect_.x() + wtpt_rect_.size().width(); ++x) {
values.push_back(floatdata.get()[y*width_+x]);
}
}
std::nth_element(values.begin(), values.begin()+(values.size()/2), values.end()); // median sort in constant time
float measured_wtpt = values[values.size()/2];
for (auto y = 0; y < height_; ++y) {
for (auto x = 0; x < width_; ++x) {
floatdata.get()[y*width_+x] /= (measured_wtpt / absolute_wtpt_values_[filter_index]);
}
}
if (filter_index == 0) { // use first filter as registration target
for (auto y = 0; y < height_; ++y) {
for (auto x = 0; x < width_; ++x) {
regdata.get()[y*width_+x] = floatdata.get()[y*width_+x];
}
}
cv::Mat regdatamat(height_, width_, CV_32F, regdata.get());
} else { // Register image to regtarget_data
// Phase-correlate based registration algorithm to align image planes based on two concentric circle targets
// Concentric targets are used because of their non-repeating nature; phase correlate gets tripped up by repeating patterns as the peaks can be matched at errant points
//cv::mat construction is efficient and does not copy data. Initialize registration target from our regdata
cv::Mat registerTo(height_, width_, CV_32F, regdata.get());
cv::Mat reg0_source, reg0_target, reg1_source, reg1_target;
cv::Mat reg0_sourcef, reg0_targetf, reg1_sourcef, reg1_targetf;
// These cv::Mats' are our registration targets; selected by the user in the main application.
//reg0_source = registration target 0 on the image that is going to be registered
//reg0_target = registration target 1 on the image that is going to be registered to
reg0_sourcef = floatdatamat(cv::Range(regtargets[0].y(), regtargets[0].y() + regtargets[0].size().height()), cv::Range(regtargets[0].x(), regtargets[0].x() + regtargets[0].size().width()));
reg0_targetf = registerTo(cv::Range(regtargets[0].y(), regtargets[0].y() + regtargets[0].size().height()), cv::Range(regtargets[0].x(), regtargets[0].x() + regtargets[0].size().width()));// - (reg_size/2), regtargets[0].y + (reg_size/2)), cv::Range(regtargets[0].x - (reg_size/2), regtargets[0].x + (reg_size/2)));
reg1_sourcef = floatdatamat(cv::Range(regtargets[1].y(), regtargets[1].y() + regtargets[1].size().height()), cv::Range(regtargets[1].x(), regtargets[1].x() + regtargets[1].size().width()));// - (reg_size/2), regtargets[1].y + (reg_size/2)), cv::Range(regtargets[1].x - (reg_size/2), regtargets[1].x + (reg_size/2)));
reg1_targetf = registerTo(cv::Range(regtargets[1].y(), regtargets[1].y() + regtargets[1].size().height()), cv::Range(regtargets[1].x(), regtargets[1].x() + regtargets[1].size().width()));// - (reg_size/2), regtargets[1].y + (reg_size/2)), cv::Range(regtargets[1].x - (reg_size/2), regtargets[1].x + (reg_size/2)));
double min, max;
cv::Point minLoc, maxLoc;
cv::minMaxLoc(reg0_sourcef, &min, &max, &minLoc, &maxLoc);
reg0_sourcef *= 255/max;
cv::minMaxLoc(reg1_sourcef, &min, &max, &minLoc, &maxLoc);
reg1_sourcef *= 255/max;
cv::minMaxLoc(reg0_targetf, &min, &max, &minLoc, &maxLoc);
reg0_targetf *= 255/max;
cv::minMaxLoc(reg1_targetf, &min, &max, &minLoc, &maxLoc);
reg1_targetf *= 255/max;
reg0_sourcef.convertTo(reg0_source, CV_8U);
reg0_targetf.convertTo(reg0_target, CV_8U);
reg1_sourcef.convertTo(reg1_source, CV_8U);
reg1_targetf.convertTo(reg1_target, CV_8U);
cv::adaptiveThreshold(reg0_source, reg0_source, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY, 11, 2);
cv::adaptiveThreshold(reg0_target, reg0_target, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY, 11, 2);
cv::adaptiveThreshold(reg1_source, reg1_source, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY, 11, 2);
cv::adaptiveThreshold(reg1_target, reg1_target, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C, cv::THRESH_BINARY, 11, 2);
reg0_source.convertTo(reg0_source, CV_32F);
reg1_source.convertTo(reg1_source, CV_32F);
reg0_target.convertTo(reg0_target, CV_32F);
reg1_target.convertTo(reg1_target, CV_32F);
reg0_sourcef /= 255;
reg0_targetf /= 255;
reg1_sourcef /= 255;
reg1_targetf /= 255;
cv::Point2d offset_center = cv::phaseCorrelate(reg0_source, reg0_target);
cv::Point2d offset_corner = cv::phaseCorrelate(reg1_source, reg1_target);
float r, r_prime, deltaX, deltaY;
deltaX = offset_corner.x - offset_center.x;
deltaY = offset_corner.y - offset_center.y;
r = pow((regtargets[1].center().x() - regtargets[0].center().x()), 2) + pow((regtargets[1].center().y() - regtargets[0].center().y()), 2);
r = sqrt(r);
r_prime = pow((regtargets[1].center().x() - regtargets[0].center().x() + deltaX), 2) + pow((regtargets[1].center().y() - regtargets[0].center().y() + deltaY), 2);
r_prime = sqrt(r_prime);
float scale = r_prime / r;
float trans_x = (floatdatamat.size().width / 2) * (1-scale);
float trans_y = (floatdatamat.size().height / 2) * (1-scale);
std::vector<float> matrix_data(6);
matrix_data[0] = scale;
matrix_data[1] = 0;
matrix_data[2] = trans_x;
matrix_data[3] = 0;
matrix_data[4] = scale;
matrix_data[5] = trans_y;
cv::Mat affine(2, 3, CV_32F, matrix_data.data());
cv::Mat scaled;
cv::warpAffine(floatdatamat, scaled, affine, floatdatamat.size());
cv::Mat scaled_target = scaled(cv::Range(regtargets[0].y(), regtargets[0].y() + regtargets[0].size().height()), cv::Range(regtargets[0].x(), regtargets[0].x() + regtargets[0].size().width()));
cv::Point2d translation_offset = cv::phaseCorrelate(scaled_target, reg0_target);
matrix_data[2] += translation_offset.x;
matrix_data[5] += translation_offset.y;
cv::warpAffine(floatdatamat, floatdatamat, affine, floatdatamat.size());
}
if (raw_tiff_path.size() > 0) {
TIFFSetField(rawdata_tiff, TIFFTAG_IMAGEWIDTH, width_);
TIFFSetField(rawdata_tiff, TIFFTAG_IMAGELENGTH, height_);
TIFFSetField(rawdata_tiff, TIFFTAG_BITSPERSAMPLE, sizeof(float) * 8);
TIFFSetField(rawdata_tiff, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_IEEEFP);
TIFFSetField(rawdata_tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(rawdata_tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
TIFFSetField(rawdata_tiff, TIFFTAG_SAMPLESPERPIXEL, 1);
TIFFSetField(rawdata_tiff, TIFFTAG_SUBFILETYPE, FILETYPE_PAGE);
TIFFSetField(rawdata_tiff, TIFFTAG_WTPTVAL, absolute_wtpt_values_[filter_index]);
TIFFSetField(rawdata_tiff, TIFFTAG_WTPTMEASURED, measured_wtpt);
TIFFSetField(rawdata_tiff, TIFFTAG_PAGENUMBER, page_index);
for (auto row = 0; row < height_; ++row) {
TIFFWriteScanline(rawdata_tiff, &floatdata.get()[row*width_], row);
}
TIFFWriteDirectory(rawdata_tiff);
++page_index;
}
int wavelength = filter_->wavelengthAtPos(filter_index);
std::vector<float> cmf = filter_->cmfValues(wavelength);
float illuminant = filter_->illuminantValue(wavelength);
for (auto y = 0; y < height_; ++y) {
for (auto x = 0; x < width_; ++x) {
for (auto xyz_index = 0; xyz_index < 3; ++xyz_index) {
xyz_data[light_index].get()->filterData(xyz_index)[y*width_+x] += floatdata.get()[y*width_+x] * cmf[xyz_index] * illuminant;
}
}
}
}
}
if (raw_tiff_path.size() > 0) {
TIFFClose(rawdata_tiff);
}
// Scale xyz data by scalar constant
for (auto light = 0; light < nlights_; ++light) {
for (auto y = 0; y < height_; ++y) {
for (auto x = 0; x < width_; ++x) {
for (auto xyz_index = 0; xyz_index < 3; ++xyz_index) {
xyz_data[light].get()->filterData(xyz_index)[y*width_+x] /= scalar_constant[xyz_index];
}
}
}
}
std::vector<XYZImage*> xyz_ptr;
for (auto i = 0; i < xyz_data.size(); ++i) {
xyz_ptr.push_back(xyz_data[i].get());
}
std::vector<float> weights(nlights_);
for (auto weight = 0; weight < weights.size(); ++weight) {
weights[weight] = 1.0 / float(nlights_);
}
master_xyz = std::shared_ptr<XYZImage>(new XYZImage(xyz_ptr, nlights_, weights));
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog)
, camera_matrix(prog)
{
// Set the vertex shader source and compile it
VertexShader vs;
vs.Source(
"#version 150\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"layout (std140) uniform ModelBlock {"
" mat4 ModelMatrices[36];"
"};"
"in vec4 Position;"
"out vec3 vertColor;"
"void main(void)"
"{"
" mat4 ModelMatrix = ModelMatrices[gl_InstanceID];"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
" vertColor = abs(normalize((ModelMatrix*Position).yxz));"
"}"
).Compile();
// set the fragment shader source and compile it
FragmentShader fs;
fs.Source(
"#version 150\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 1.0);"
"}"
).Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link().Use();
projection_matrix.BindTo("ProjectionMatrix");
camera_matrix.BindTo("CameraMatrix");
// bind the VAO for the cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
(prog|"Position").Setup<GLfloat>(n_per_vertex).Enable();
}
// make the matrices
{
// 36 x 4x4 matrices
std::vector<GLfloat> matrix_data(36*16);
auto p = matrix_data.begin(), e = matrix_data.end();
Angle<GLfloat> angle, astep = Angle<GLfloat>::Degrees(10);
while(p != e)
{
GLfloat cx = Cos(angle);
GLfloat sx = Sin(angle);
auto matrix = Transposed(Mat4f(
Vec4f( cx, 0.0, -sx, 0.0),
Vec4f(0.0, 1.0, 0.0, 0.0),
Vec4f( sx, 0.0, cx, 0.0),
Vec4f(0.0, 0.0, 0.0, 1.0)
) * Mat4f(
Vec4f(1.0, 0.0, 0.0,12.0),
Vec4f(0.0, 1.0, 0.0, 0.0),
Vec4f(0.0, 0.0, 1.0, 0.0),
Vec4f(0.0, 0.0, 0.0, 1.0)
));
p = std::copy(
Data(matrix),
Data(matrix)+Size(matrix),
p
);
angle += astep;
}
UniformBlock model_block(prog, "ModelBlock");
model_block.Binding(0);
block_buf.Bind(Buffer::Target::Uniform);
Buffer::Data(
Buffer::Target::Uniform,
matrix_data,
BufferUsage::DynamicDraw
);
block_buf.BindBaseUniform(0);
}
//
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
/*
%F Seta a celula que contem o focus. Se a celula nao estiver visivel,
muda a parte visivel da matriz para conter a celula como o foco.
%i h : handle da matriz,
v : string contendo a celula que vai conter o foco. E da forma "%d:%d",
onde o primeiro numero indica a linha e o segundo a coluna. "1:1"
corresponde a celula do canto superior esquerdo.
*/
void iupmatSetFocusPosition(Ihandle *h, char *v, int call_cb)
{
Tmat *mat=(Tmat*)matrix_data(h);
int lin,col;
int redraw = 0;
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
IsCanvasSet(mat,err);
if (!v) return;
if (iupStrToIntInt(v,&lin,&col,':')!=2)
return;
/* Se a celula nao existe, retorna */
if ((lin < 1) || (col < 1) || (lin > mat_nl(mat)) || (col > mat_nc(mat)))
return;
lin--; /* a celula superior esquerda e 1:1 para o usuario, */
col--; /* internamente ela e 0:0 */
if (mat_w(mat)[col] == 0)
return;
/* se a matriz esta' com focus, pede permissao a aplicacao */
/* para sair da celula. Quando a matriz nao esta' com o */
/* focus, a aplicacao ja' foi avisada na perda do focus */
if (mat_hasiupfocus(mat) && call_cb)
{
if (iupmatCallLeavecellCb(h) == IUP_IGNORE)
return;
}
/* Se a linha estiver invisivel */
if (lin<mat_fl(mat) || lin>mat_ll(mat))
{
/* faz a primeira linha ser aquela que vai conter o focus */
mat_fl(mat) = lin;
iupmatGetLastWidth(h,MAT_LIN);
redraw = 1;
}
/* Se a coluna estiver invisivel */
if (col<mat_fc(mat) || col>mat_lc(mat))
{
/* Faz a primeira coluna ser aquela que vai conter o focus */
mat_fc(mat) = col;
iupmatGetLastWidth(h,MAT_COL);
redraw = 1;
}
if(visible && err == CD_OK)
{
iupmatHideFocus(h);
iupmatSetFocusPos(h,lin,col);
if (redraw)
iupmatDrawMatrix(h,DRAW_ALL);
iupmatShowFocus(h);
}
/* Se a matriz esta' com focus, avisa a aplicacao da nova
celula que tem o foco. Caso contrario, quando a matriz
ganhar o foco entao a aplicacao sera avisada.
*/
if (mat_hasiupfocus(mat) && call_cb)
iupmatCallEntercellCb(h);
}
/*
%F Funcao para setar qual a area visivel da matriz. Faz isto a partir
da informacao de qual celula deve ser colocada no canto superior
esquerdo da matriz.
%i h - Handle da matriz
value - Informacao de qual a celula que deve ficar no canto superio
esquerdo da matriz, codificada no formato lin:col.
*/
void iupmatSetOrigin(Ihandle *h, char *value)
{
Tmat *mat = (Tmat*)matrix_data(h);
Ihandle *d = IupGetDialog(h);
int visible = (iupCheck(h,IUP_VISIBLE)==YES) && (iupCheck(d,IUP_VISIBLE)==YES);
int err;
int lin=-1,col=-1,oldlin,oldcol,num=0;
if (value == NULL)
return;
/* Pega os parametros. Um '*' indica que quero manter a tabela na mesma
linha ou coluna.
*/
if (iupStrToIntInt(value,&lin,&col,':') != 2)
{
if (lin != -1)
col = mat_fc(mat) + 1;
else if(col != -1)
lin = mat_fl(mat) + 1;
else
return;
}
/* Se a celula nao existe, retorna NULL */
if ((lin < 1) || (col < 1) || (lin > mat_nl(mat)) || (col > mat_nc(mat)))
return;
/* TODO: allow position based on the title cells also */
lin--; /* a celula superior esquerda e 1:1 para o usuario, */
col--; /* internamente ela e 0:0 */
IsCanvasSet(mat,err);
oldcol = mat_fc(mat);
oldlin = mat_fl(mat);
mat_fc(mat) = col;
iupmatGetLastWidth(h,MAT_COL);
iupmatGetPos(h,MAT_COL);
mat_fl(mat) = lin;
iupmatGetLastWidth(h,MAT_LIN);
iupmatGetPos(h,MAT_LIN);
num = abs(oldcol - mat_fc(mat)) + abs(oldlin - mat_fl(mat));
/* Se a matriz esta visivel, e houve mudanca na parte visivel da mesma,
entao redesenha...
*/
if (visible && (err == CD_OK) && num)
{
iupmatHideFocus(h);
if(num == 1)
{
if(oldlin != mat_fl(mat))
iupmatScroll(h,oldlin < mat_fl(mat)?SCROLL_DOWN:SCROLL_UP,oldlin,1);
else
iupmatScroll(h,oldcol < mat_fc(mat)?SCROLL_RIGHT:SCROLL_LEFT,oldcol,1);
SetSbV;
SetSbH;
}
else
{
SetSbV;
SetSbH;
iupmatDrawMatrix(h,DRAW_ALL);
}
iupmatShowFocus(h);
mat->redraw = 1;
}
}
