int main(int argc, const char * argv[])
{
std::string filename = "../data/ye_high2.png";
if (argc > 1) {
filename = argv[1];
}
ColorImageR8G8B8A8 image = LodePNG::load(filename);
ColorImageR32G32B32A32 imageR32(image.getWidth(), image.getHeight());
for (unsigned int y = 0; y < image.getHeight(); y++) {
for (unsigned int x = 0; x < image.getWidth(); x++) {
imageR32(x,y) = image(x,y);
}
}
CombinedSolverParameters params;
params.nonLinearIter = 7;
params.linearIter = 10;
CombinedSolver solver(imageR32, params);
solver.solveAll();
ColorImageR32G32B32A32* res = solver.getAlbedo();
ColorImageR8G8B8A8 out(res->getWidth(), res->getHeight());
for (unsigned int y = 0; y < res->getHeight(); y++) {
for (unsigned int x = 0; x < res->getWidth(); x++) {
unsigned char r = math::round(math::clamp(255.0f*(*res)(x, y).x, 0.0f, 255.0f));
unsigned char g = math::round(math::clamp(255.0f*(*res)(x, y).y, 0.0f, 255.0f));
unsigned char b = math::round(math::clamp(255.0f*(*res)(x, y).z, 0.0f, 255.0f));
out(x, y) = vec4uc(r, g, b,255);
}
}
LodePNG::save(out, "outputAlbedo.png");
res = solver.getShading();
ColorImageR8G8B8A8 out2(res->getWidth(), res->getHeight());
for (unsigned int y = 0; y < res->getHeight(); y++) {
for (unsigned int x = 0; x < res->getWidth(); x++) {
unsigned char r = math::round(255.0f*math::clamp((*res)(x, y).x, 0.0f, 255.0f));
unsigned char g = math::round(255.0f*math::clamp((*res)(x, y).y, 0.0f, 255.0f));
unsigned char b = math::round(255.0f*math::clamp((*res)(x, y).z, 0.0f, 255.0f));
out2(x, y) = vec4uc(r, g, b, 255);
}
}
LodePNG::save(out2, "outputShading.png");
return 0;
}
Bitmap FCSVisualizer::visualizeDensity(const FCSFile &file, const FCSProcessor &processor, int axisA, int axisB, int imageSize, int clusterFilter, const QuartileRemap ¶ms)
{
Grid2f cells(imageSize, imageSize, 0.0f);
const int borderSize = 1;
for (const MathVectorf &sample : file.transformedSamples)
{
if (clusterFilter != -1 && processor.clustering.getClusterIndex(sample) != clusterFilter)
continue;
vec2f v;
v.x = sample[axisA];
v.y = 1.0f - sample[axisB];
//if (v.x < 0.0f || v.y < 0.0f || v.x > 1.0f || v.y > 1.0f) cout << "bounds: " << v << endl;
vec2i coord = math::round(v * (float)imageSize);
if (cells.isValidCoordinate(coord) &&
coord.x >= borderSize && coord.x < imageSize - borderSize &&
coord.y >= borderSize && coord.y < imageSize - borderSize)
{
cells(coord)++;
}
}
QuartileRemap paramsFinal = params;
if (params.quartiles.size() == 0)
{
vector<float> nonzeroValues;
for (auto &v : cells)
if (v.value > 1.0f) nonzeroValues.push_back(v.value);
std::sort(nonzeroValues.begin(), nonzeroValues.end());
if (nonzeroValues.size() == 0)
nonzeroValues.push_back(1.0f);
paramsFinal.quartiles.resize(8);
paramsFinal.quartiles[0] = 0.0f;
paramsFinal.quartiles[1] = nonzeroValues[(int)(nonzeroValues.size() * 0.2f)];
paramsFinal.quartiles[2] = nonzeroValues[(int)(nonzeroValues.size() * 0.4f)];
paramsFinal.quartiles[3] = nonzeroValues[(int)(nonzeroValues.size() * 0.6f)];
paramsFinal.quartiles[4] = nonzeroValues[(int)(nonzeroValues.size() * 0.7f)];
paramsFinal.quartiles[5] = nonzeroValues[(int)(nonzeroValues.size() * 0.85f)];
paramsFinal.quartiles[6] = nonzeroValues[(int)(nonzeroValues.size() * 0.98f)];
paramsFinal.quartiles[7] = nonzeroValues.back();
//params.quartiles = { 0.0f, 3.0f, 6.0f, 12.0f, 20.0f, 50.0f, 200.0f, 400.0f };
//paramsFinal.print();
}
Bitmap result(imageSize, imageSize);
for (auto &v : cells)
{
float intensity = paramsFinal.transform(v.value) * 255.0f;
unsigned char c = util::boundToByte(intensity);
result(v.x, v.y) = vec4uc(c, c, c, 255);
}
return result;
}
void ObjectAnalyzer::init(const SegmentDatabase &segments, const vec2i &screenDimensions)
{
objects.resize(segments.objects.size());
for (ObjectStatistics &o : objects)
{
o.heatmap.allocate(screenDimensions.x, screenDimensions.y);
o.heatmap.setPixels(vec4uc(0, 0, 0, 255));
}
}
Bitmap FCSFeatures::getChannel(int channel) const
{
Bitmap result((int)features.getDimX(), (int)features.getDimY());
for (auto &p : result)
{
BYTE v = features(p.x, p.y, channel);
p.value = vec4uc(v, v, v, 255);
}
return result;
}
Bitmap FCSVisualizer::gridToBmp(const Grid2f &g, float scale)
{
Bitmap bmp((int)g.getDimX(), (int)g.getDimY());
for (auto &p : bmp)
{
const float valueF = g(p.x, p.y) * scale;
BYTE valueB = util::boundToByte(valueF);
p.value = vec4uc(valueB, valueB, valueB, 255);
}
return bmp;
}
void ObjectAnalyzer::AnalyzeFrame(const SegmentDatabase &segments, const ReplayFrame &frame)
{
map<int, int> objectOccurrences;
for (auto &o : frame.objectAnnotations)
{
objectOccurrences[o.objectID]++;
objects[o.objectID].heatmap(o.origin.x, o.origin.y) = vec4uc(255, 0, 0, 255);
objects[o.objectID].segmentHashes.insert(frame.segmentAnnotations[o.segments[0]].segmentHash);
}
for (auto &p : objectOccurrences)
{
ObjectStatistics &stats = objects[p.first];
while (stats.frameOccurrenceCount.size() <= p.second)
stats.frameOccurrenceCount.push_back(0);
stats.frameOccurrenceCount[p.second]++;
}
}
bool SensorDataReader::processDepth()
{
if (m_currFrame >= m_numFrames)
{
GlobalAppState::get().s_playData = false;
//std::cout << "binary dump sequence complete - press space to run again" << std::endl;
stopReceivingFrames();
std::cout << "binary dump sequence complete - stopped receiving frames" << std::endl;
m_currFrame = 0;
}
if (GlobalAppState::get().s_playData) {
float* depth = getDepthFloat();
//TODO check why the frame cache is not used?
ml::SensorData::RGBDFrameCacheRead::FrameState frameState = m_sensorDataCache->getNext();
//ml::SensorData::RGBDFrameCacheRead::FrameState frameState;
//frameState.m_colorFrame = m_sensorData->decompressColorAlloc(m_currFrame);
//frameState.m_depthFrame = m_sensorData->decompressDepthAlloc(m_currFrame);
for (unsigned int i = 0; i < getDepthWidth()*getDepthHeight(); i++) {
if (frameState.m_depthFrame[i] == 0) depth[i] = -std::numeric_limits<float>::infinity();
else depth[i] = (float)frameState.m_depthFrame[i] / m_sensorData->m_depthShift;
}
incrementRingbufIdx();
if (m_bHasColorData) {
for (unsigned int i = 0; i < getColorWidth()*getColorHeight(); i++) {
m_colorRGBX[i] = vec4uc(frameState.m_colorFrame[i]);
}
}
frameState.free();
m_currFrame++;
return true;
}
else {
return false;
}
}
void Logger::recordSignatureColorPostDraw(MyD3DAssets &assets, const DrawParameters ¶ms, const GPUDrawBuffers &buffers)
{
if (!capturingColorSignature)
{
return;
}
assets.context->readRenderTarget(postRenderImage);
vec3f diffSum = vec3f::origin;
int diffCount = 0;
for (auto &p : postRenderImage)
{
if (p.value != preRenderImage(p.x, p.y))
{
diffSum += vec3f(p.value.getVec3()) / 255.0f;
diffCount++;
}
}
newSignaturesThisFrame++;
colorMap.record(params.signature, diffCount == 0 ? vec3f::origin : diffSum / (float)diffCount, diffCount);
if (!geoDatabase.hasSignature(params.signature))
{
LocalizedObject object;
object.load(assets, params, buffers, true);
object.center();
if (object.data.signature != params.signature) logErrorFile << "inconsistent signatures" << endl;
Bitmap diffImage = postRenderImage;
for (auto &p : diffImage)
{
if (p.value == preRenderImage(p.x, p.y))
{
p.value = vec4uc(0, 0, 0, 255);
}
}
geoDatabase.record(object, diffImage);
}
}
void Logger::recordDrawEvent(MyD3DAssets &assets, const DrawParameters ¶ms)
{
if (capturingFrame && assets.viewportFullScreen())
{
GPUDrawBuffers buffers(assets);
LocalizedObject object;
object.load(assets, params, buffers, true);
if (object.vertices.size() > 0)
{
frameCaptureObjects.frames[0]->objectData.push_back(object.data);
frameCaptureObjects.frames[0]->objectMeshes.push_back(object);
}
const BufferCPU *VSConstants = assets.getVSConstantBuffer();
const auto &indexBuffer = assets.getActiveIndexBuffer();
const auto &vertexBuffer = assets.getActiveVertexBuffer();
const string imagePrefix = "render" + (useLinearCaptureNumbering ? util::zeroPad(frameOutputIndex, 5) : util::zeroPad(frameRenderIndex, 5));
const string frameImageFile = imagePrefix + "_frame.png";
const string frameDeltaImageFile = imagePrefix + "_delta.png";
const string texImageFile = imagePrefix + "_tex";
if (outputImages)
{
Bitmap image;
assets.context->readRenderTarget(image);
LodePNG::save(image, g_logger->captureDir + frameImageFile);
frameOutputIndex++;
if (prevCaptureImage.getDimensions() == image.getDimensions())
{
Bitmap deltaImage = image;
for (auto &p : deltaImage)
{
if (p.value == prevCaptureImage(p.x, p.y))
p.value = vec4uc(0, 0, 0, 255);
}
LodePNG::save(deltaImage, g_logger->captureDir + frameDeltaImageFile);
}
prevCaptureImage = image;
}
auto modifyImage = [](Bitmap &b)
{
if (b.size() == 0) return;
for (auto &p : b)
{
p.value.r = unsigned char((int)p.value.r * (int)p.value.a / 255);
p.value.g = unsigned char((int)p.value.g * (int)p.value.a / 255);
p.value.b = unsigned char((int)p.value.b * (int)p.value.a / 255);
p.value.a = 255;
}
};
for (int textureIndex = 0; textureIndex < textureOutputCount; textureIndex++)
{
assets.loadPSTexture(textureIndex);
modifyImage(assets.PSTexture);
if (assets.PSTexture.size() > 0 && outputImages)
LodePNG::save(assets.PSTexture, g_logger->captureDir + texImageFile + to_string(textureIndex) + ".png");
}
auto makeHTMLImage = [](const string &filename)
{
return "<img src=\"" + filename + "\" />";
};
logFrameCaptureHtml << "<tr>" << endl;
logFrameCaptureHtml << "<td>" << frameRenderIndex << "</td>" << endl;
logFrameCaptureHtml << "<td>" << makeHTMLImage(frameImageFile) << "</td>" << endl;
logFrameCaptureHtml << "<td>" << makeHTMLImage(frameDeltaImageFile) << "</td>" << endl;
for (int texIndex = 0; texIndex < textureOutputCount; texIndex++)
logFrameCaptureHtml << "<td>" << makeHTMLImage(texImageFile + to_string(texIndex) + ".png") << "</td>" << endl;
auto viewport = assets.getViewport();
logFrameCaptureHtml << "<td>" << object.data.signature << "<br />" << "viewport: " << viewport.Width << "," << viewport.Height << "</td>" << endl;
logFrameCaptureHtml << "<td>" << params.IndexCount << ", " << params.StartIndexLocation << ", " << params.BaseVertexLocation << "</td>" << endl;
logFrameCaptureHtml << "<td>" << ((indexBuffer.buffer == nullptr) ? "invalid" : to_string(indexBuffer.buffer->data.size())) + " " + pointerToString(indexBuffer.buffer->GPUHandle) << "</td>" << endl;
//logFrameCaptureHtml << "<td>" << indexBuffer.offset << "</td>" << endl;
logFrameCaptureHtml << "<td>" << ((vertexBuffer.buffer == nullptr) ? "invalid" : to_string(vertexBuffer.buffer->data.size())) + " " + pointerToString(vertexBuffer.buffer->GPUHandle) << "</td>" << endl;
//logFrameCaptureHtml << "<td>" << vertexBuffer.offset << "</td>" << endl;
logFrameCaptureHtml << "<td>" << vertexBuffer.stride << "</td>" << endl;
string v0Data = "<none>";
if (params.BaseVertexLocation != -1 && vertexBuffer.buffer != nullptr && indexBuffer.buffer != nullptr)
{
const WORD *indexDataStart = (WORD *)indexBuffer.buffer->data.data() + params.StartIndexLocation;
const BYTE *vertexData = vertexBuffer.buffer->data.data();
v0Data = "";
const auto *layout = assets.activeVertexLayout;
if (layout == nullptr)
{
v0Data = "layout not found";
}
else
{
v0Data += layout->htmlDescription;
v0Data += "data:<br />";
for (int indexIndex = 0; indexIndex < min((int)params.IndexCount, 32); indexIndex++)
{
string vertexPrefix = "V" + to_string(indexIndex) + " ";
const int curIndex = indexDataStart[indexIndex] + params.BaseVertexLocation;
const BYTE *curVertex = (vertexData + (vertexBuffer.stride * curIndex));
if (vertexBuffer.buffer->data.size() < vertexBuffer.stride * (curIndex + 1))
{
v0Data += "*out of bounds*<br />";
continue;
}
const int pOffset = assets.activeVertexLayout->positionOffset;
const int bOffset = assets.activeVertexLayout->blendOffset;
const int tOffset = assets.activeVertexLayout->tex0Offset;
int blendMatrixIndex = -1;
if (bOffset != -1)
{
vec4uc blendIndices = *((const vec4uc *)(curVertex + bOffset));
blendMatrixIndex = blendIndices.x;
}
const float *pStart = (const float *)(curVertex + pOffset);
const vec3f basePos(pStart[0], pStart[1], pStart[2]);
vec3f pos = assets.transformObjectToWorldGamecube(VSConstants, basePos, blendMatrixIndex);
vec2f tex = vec2f::origin;
if (tOffset != -1)
{
const float *tStart = (const float *)(curVertex + tOffset);
tex = vec2f(tStart[0], tStart[1]);
}
v0Data += vertexPrefix + "world=" + pos.toString(", ") + " <br/>";
v0Data += vertexPrefix + "index=" + to_string(curIndex) + " <br/>";
v0Data += vertexPrefix + "tex=" + tex.toString(", ") + " <br/>";
}
}
}
logFrameCaptureHtml << "<td>" << v0Data << "</td>" << endl;
logFrameCaptureHtml << "</tr>" << endl;
}
