void load_dataset1(string &ds_name, string &data_fname) {
string labels_fname;
build_fname(ds_name, LABELS_NAME, labels_fname);
// determine label type
switch (get_matrix_type(labels_fname.c_str())) {
case MAGIC_BYTE_MATRIX:
case MAGIC_UBYTE_VINCENT:
load_dataset2<Tdata, ubyte>(ds_name, data_fname, labels_fname);
break ;
case MAGIC_INTEGER_MATRIX:
case MAGIC_INT_VINCENT:
load_dataset2<Tdata, int>(ds_name, data_fname, labels_fname);
break ;
case MAGIC_FLOAT_MATRIX:
case MAGIC_FLOAT_VINCENT:
load_dataset2<Tdata, float>(ds_name, data_fname, labels_fname);
break ;
case MAGIC_DOUBLE_MATRIX:
case MAGIC_DOUBLE_VINCENT:
load_dataset2<Tdata, double>(ds_name, data_fname, labels_fname);
break ;
case MAGIC_LONG_MATRIX:
load_dataset2<Tdata, long>(ds_name, data_fname, labels_fname);
break ;
case MAGIC_UINT_MATRIX:
load_dataset2<Tdata, uint>(ds_name, data_fname, labels_fname);
break ;
default:
eblerror("unknown magic number in label matrix");
}
}
void GrGLVertexProgramEffects::emitTransforms(GrGLFullShaderBuilder* builder,
const GrDrawEffect& drawEffect,
TransformedCoordsArray* outCoords) {
SkTArray<Transform, true>& transforms = fTransforms.push_back();
uint32_t totalKey = GenTransformKey(drawEffect);
int numTransforms = drawEffect.effect()->numTransforms();
transforms.push_back_n(numTransforms);
for (int t = 0; t < numTransforms; t++) {
GrSLType varyingType = kVoid_GrSLType;
const char* uniName;
switch (get_matrix_type(totalKey, t)) {
case kNoPersp_MatrixType:
uniName = "StageMatrix";
varyingType = kVec2f_GrSLType;
break;
case kGeneral_MatrixType:
uniName = "StageMatrix";
varyingType = kVec3f_GrSLType;
break;
default:
SkFAIL("Unexpected key.");
}
SkString suffixedUniName;
if (0 != t) {
suffixedUniName.append(uniName);
suffixedUniName.appendf("_%i", t);
uniName = suffixedUniName.c_str();
}
transforms[t].fHandle = builder->addUniform(GrGLShaderBuilder::kVertex_Visibility,
kMat33f_GrSLType,
uniName,
&uniName);
const char* varyingName = "MatrixCoord";
SkString suffixedVaryingName;
if (0 != t) {
suffixedVaryingName.append(varyingName);
suffixedVaryingName.appendf("_%i", t);
varyingName = suffixedVaryingName.c_str();
}
const char* vsVaryingName;
const char* fsVaryingName;
builder->addVarying(varyingType, varyingName, &vsVaryingName, &fsVaryingName);
const GrGLShaderVar& coords = kPosition_GrCoordSet == get_source_coords(totalKey, t) ?
builder->positionAttribute() :
builder->localCoordsAttribute();
// varying = matrix * coords (logically)
SkASSERT(kVec2f_GrSLType == varyingType || kVec3f_GrSLType == varyingType);
if (kVec2f_GrSLType == varyingType) {
builder->vsCodeAppendf("\t%s = (%s * vec3(%s, 1)).xy;\n",
vsVaryingName, uniName, coords.c_str());
} else {
builder->vsCodeAppendf("\t%s = %s * vec3(%s, 1);\n",
vsVaryingName, uniName, coords.c_str());
}
SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords,
(SkString(fsVaryingName), varyingType));
}
}
void GrGLPathTexGenProgramEffects::setPathTexGenState(GrGpuGL* gpu,
const GrDrawEffect& drawEffect,
int effectIdx) {
uint32_t totalKey = fTransforms[effectIdx].fTransformKey;
int texCoordIndex = fTransforms[effectIdx].fTexCoordIndex;
int numTransforms = drawEffect.effect()->numTransforms();
for (int t = 0; t < numTransforms; ++t) {
switch (get_matrix_type(totalKey, t)) {
case kNoPersp_MatrixType: {
const SkMatrix& transform = get_transform_matrix(drawEffect, t);
gpu->enablePathTexGen(texCoordIndex++,
GrGpuGL::kST_PathTexGenComponents,
transform);
break;
}
case kGeneral_MatrixType: {
const SkMatrix& transform = get_transform_matrix(drawEffect, t);
gpu->enablePathTexGen(texCoordIndex++,
GrGpuGL::kSTR_PathTexGenComponents,
transform);
break;
}
default:
SkFAIL("Unexpected matrixs type.");
}
}
}
void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyShaderBuilder* builder,
const GrDrawEffect& drawEffect,
TransformedCoordsArray* outCoords) {
int numTransforms = drawEffect.effect()->numTransforms();
uint32_t totalKey = GenTransformKey(drawEffect);
int texCoordIndex = builder->addTexCoordSets(numTransforms);
SkNEW_APPEND_TO_TARRAY(&fTransforms, Transforms, (totalKey, texCoordIndex));
SkString name;
for (int t = 0; t < numTransforms; ++t) {
GrSLType type = kGeneral_MatrixType == get_matrix_type(totalKey, t) ?
kVec3f_GrSLType :
kVec2f_GrSLType;
name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++);
SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, (name, type));
}
}
void GrGLPathTexGenProgramEffects::setPathTexGenState(GrGpuGL* gpu,
const GrDrawEffect& drawEffect,
int effectIdx) {
EffectKey totalKey = fTransforms[effectIdx].fTransformKey;
int texCoordIndex = fTransforms[effectIdx].fTexCoordIndex;
int numTransforms = (*drawEffect.effect())->numTransforms();
for (int t = 0; t < numTransforms; ++t) {
switch (get_matrix_type(totalKey, t)) {
case kIdentity_MatrixType: {
SkASSERT(get_transform_matrix(drawEffect, t).isIdentity());
GrGLfloat identity[] = {1, 0, 0,
0, 1, 0};
gpu->enablePathTexGen(texCoordIndex++,
GrGpuGL::kST_PathTexGenComponents,
identity);
break;
}
case kTrans_MatrixType: {
GrGLfloat tx, ty;
get_transform_translation(drawEffect, t, &tx, &ty);
GrGLfloat translate[] = {1, 0, tx,
0, 1, ty};
gpu->enablePathTexGen(texCoordIndex++,
GrGpuGL::kST_PathTexGenComponents,
translate);
break;
}
case kNoPersp_MatrixType: {
const SkMatrix& transform = get_transform_matrix(drawEffect, t);
gpu->enablePathTexGen(texCoordIndex++,
GrGpuGL::kST_PathTexGenComponents,
transform);
break;
}
case kGeneral_MatrixType: {
const SkMatrix& transform = get_transform_matrix(drawEffect, t);
gpu->enablePathTexGen(texCoordIndex++,
GrGpuGL::kSTR_PathTexGenComponents,
transform);
break;
}
default:
SkFAIL("Unexpected matrixs type.");
}
}
}
void GrGLPathTexGenProgramEffects::setupPathTexGen(GrGLFragmentOnlyShaderBuilder* builder,
const GrEffectRef& effect,
EffectKey effectKey,
TransformedCoordsArray* outCoords) {
int numTransforms = effect->numTransforms();
EffectKey totalKey = GrBackendEffectFactory::GetTransformKey(effectKey);
int texCoordIndex = builder->addTexCoordSets(numTransforms);
SkNEW_APPEND_TO_TARRAY(&fTransforms, Transforms, (totalKey, texCoordIndex));
SkString name;
for (int t = 0; t < numTransforms; ++t) {
GrSLType type = kGeneral_MatrixType == get_matrix_type(totalKey, t) ?
kVec3f_GrSLType :
kVec2f_GrSLType;
name.printf("%s(gl_TexCoord[%i])", GrGLSLTypeString(type), texCoordIndex++);
SkNEW_APPEND_TO_TARRAY(outCoords, TransformedCoords, (name, type));
}
}
//! Retrieve type so that we know if we can look
//! for negative values when estimating range.
int load_display(list<string>::iterator &ifname,
bool load, list<string> *mats) {
try {
switch (get_matrix_type((*ifname).c_str())) {
case MAGIC_BYTE_MATRIX:
case MAGIC_UBYTE_VINCENT:
return display<ubyte>(ifname, false, load, mats);
break ;
case MAGIC_INTEGER_MATRIX:
case MAGIC_INT_VINCENT:
return display<int>(ifname, true, load, mats);
break ;
case MAGIC_FLOAT_MATRIX:
case MAGIC_FLOAT_VINCENT:
return display<float>(ifname, true, load, mats);
break ;
case MAGIC_DOUBLE_MATRIX:
case MAGIC_DOUBLE_VINCENT:
return display<double>(ifname, true, load, mats);
break ;
case MAGIC_LONG_MATRIX:
return display<long>(ifname, true, load, mats);
break ;
case MAGIC_UINT_MATRIX:
#ifndef __WINDOWS__
return display<uint>(ifname, false, load, mats);
#else
eblerror("matshow for UINT disabled in Windows");
#endif
break ;
default: // not a matrix, try as regular float image
return display<float>(ifname, true, load, mats);
}
} eblcatcherror();
return 0;
}
// TODO: if types differ, print warning and cast to expected type
// TODO: allow not knowing order in advance (just assign new idx to m)
int get_matrix_type(const char *filename, std::string &type) {
int magic = get_matrix_type(filename);
type = get_magic_str(magic);
return magic;
}
MAIN_QTHREAD(int, argc, char**, argv) {
#else
int main(int argc, char **argv) {
#endif
// names of dataset and files to load
string ds_name;
string data_fname;
// parse arguments
if (!parse_args(argc, argv, ds_name)) {
print_usage();
return -1;
}
if (!size) {
cout <<
"___________________________________________________________________";
cout << endl << endl;
cout << " Dataset display for libeblearn library " << endl;
cout <<
"___________________________________________________________________";
cout << endl;
// print info
cout << "input parameters:" << endl;
cout << " dataset name: " << ds_name << endl;
cout << " info only: " << (info ? "yes" : "no") << endl;
cout << " size only: " << (size ? "yes" : "no") << endl;
cout << " values range: ";
for (vector<double>::iterator i = range.begin(); i != range.end(); ++i)
cout << *i << " ";
cout << endl;
cout << " display dimensions: " << dims << endl;
cout << " font size: " << font_size << endl;
cout <<
"___________________________________________________________________";
cout << endl;
}
// build file names
build_fname(ds_name, DATA_NAME, data_fname);
// select data type
try {
switch (get_matrix_type(data_fname.c_str())) {
case MAGIC_BYTE_MATRIX:
case MAGIC_UBYTE_VINCENT:
load_dataset1<ubyte>(ds_name, data_fname);
break ;
case MAGIC_INTEGER_MATRIX:
case MAGIC_INT_VINCENT:
load_dataset1<int>(ds_name, data_fname);
break ;
case MAGIC_FLOAT_MATRIX:
case MAGIC_FLOAT_VINCENT:
load_dataset1<float>(ds_name, data_fname);
break ;
case MAGIC_DOUBLE_MATRIX:
case MAGIC_DOUBLE_VINCENT:
load_dataset1<double>(ds_name, data_fname);
break ;
case MAGIC_LONG_MATRIX:
load_dataset1<long>(ds_name, data_fname);
break ;
case MAGIC_UINT_MATRIX:
load_dataset1<uint>(ds_name, data_fname);
break ;
default:
eblerror("unknown magic number in data matrix");
}
} eblcatcherror();
secsleep(20);
return 0;
}
int display(list<string>::iterator &ifname,
bool signd, bool load, list<string> *mats) {
//cout << "displaying " << ifname->c_str() << endl;
// conf mode
if (conf)
return display_net<T>(ifname, signd, load, mats);
// mat mode
if (is_matrix(ifname->c_str())) {
idxdim d = get_matrix_dims(ifname->c_str());
if (interleaved)
d.shift_dim(0, 2);
if (save_individually || print
|| !(d.order() == 2 || (d.order() == 3 &&
(d.dim(2) == 1 || d.dim(2) == 3)))) {
// this is probably not an image, just display info and print matrix
string type;
get_matrix_type(ifname->c_str(), type);
idx<T> m = load_matrix<T>(ifname->c_str());
cout << "Matrix " << ifname->c_str() << " is of type " << type
<< " with dimensions " << d << " (min " << idx_min(m)
<< ", max " << idx_max(m) << ", mean " << idx_mean(m)
<< "):" << endl;
m.print();
if (has_multiple_matrices(ifname->c_str())) {
midx<T> ms = load_matrices<T>(ifname->c_str(), true);
// saving sub-matrices
if (save_individually) {
cout << "Saving each sub-matrix of " << *ifname << " individually..."
<< endl;
save_matrices_individually(ms, *ifname, true);
}
// printing sub-matrices
cout << "This file contains " << m << " matrices: ";
if (ms.order() == 1) {
for (intg i = 0; i < ms.dim(0); ++i) {
idx<T> tmp = ms.mget(i);
cout << tmp.info() << " ";
}
} else if (ms.order() == 2) {
for (intg i = 0; i < ms.dim(0); ++i) {
for (intg j = 0; j < ms.dim(1); ++j) {
idx<T> tmp = ms.mget(i, j);
cout << tmp.info() << " ";
}
cout << endl;
}
}
cout << endl;
} else
cout << "This is a single-matrix file." << endl;
return 0;
}
}
// image mode
int loaded = 0;
static idx<T> mat;
uint h = 0, w = 0, rowh = 0, maxh = 0;
list<string>::iterator fname = ifname;
#ifdef __GUI__
disable_window_updates();
clear_window();
if (show_filename) {
gui << at(h, w) << black_on_white() << ifname->c_str();
h += 16;
}
#endif
maxh = h;
for (uint i = 0; i < nh; ++i) {
rowh = maxh;
for (uint j = 0; j < nw; ++j) {
if (fname == mats->end())
fname = mats->begin();
try {
// if (load)
mat = load_image<T>(*fname);
if (print)
cout << *fname << ": " << mat << endl << mat.str() << endl;
// show only some channels
if (chans >= 0)
mat = mat.select(2, chans);
loaded++;
maxh = (std::max)(maxh, (uint) (rowh + mat.dim(0)));
T min = 0, max = 0;
#ifdef __GUI__
if (autorange || signd) {
if (autorange) {
min = idx_min(mat);
max = idx_max(mat);
} else if (signd) {
T matmin = idx_min(mat);
if ((double)matmin < 0) {
min = -1;
max = -1;
}
}
draw_matrix(mat, rowh, w, zoom, zoom, min, max);
} else
draw_matrix(mat, rowh, w, zoom, zoom, (T) range[0], (T) range[1]);
#endif
w += mat.dim(1) + 1;
} catch(string &err) {
ERROR_MSG(err.c_str());
}
fname++;
if (fname == ifname)
break ;
}
if (fname == ifname)
break ;
maxh++;
w = 0;
}
#ifdef __GUI__
// info
if (show_info) {
set_text_colors(0, 0, 0, 255, 255, 255, 255, 200);
gui << mat;
gui << at(15, 0) << *fname;
gui << at(29, 0) << "min: " << idx_min(mat) << " max: " << idx_max(mat);
}
// help
if (show_help) {
h = 0;
w = 0;
uint hstep = 14;
set_text_colors(0, 0, 255, 255, 255, 255, 255, 200);
gui << at(h, w) << "Controls:"; h += hstep;
set_text_colors(0, 0, 0, 255, 255, 255, 255, 200);
gui << at(h, w) << "Right/Space: next image"; h += hstep;
gui << at(h, w) << "Left/Backspace: previous image"; h += hstep;
gui << at(h, w) << "i: image info"; h += hstep;
gui << at(h, w) << "a: auto-range (use min and max as range)"; h += hstep;
gui << at(h, w) << "x/z: show more/less images on width axis"; h += hstep;
gui << at(h, w) << "y/t: show more/less images on height axis"; h += hstep;
gui << at(h, w) << "0,1,2: show channel 0, 1 or 2 only"; h += hstep;
gui << at(h, w) << "9: show alls channels"; h += hstep;
gui << at(h, w) << "h: help";
}
// update title
string title;
title << "matshow: " << ebl::basename(ifname->c_str());
set_window_title(title.c_str());
enable_window_updates();
#endif
return loaded;
}
