1008 lines
34 KiB
C++
1008 lines
34 KiB
C++
#include <SDL2/SDL_events.h>
|
|
#include <SDL2/SDL_scancode.h>
|
|
#include <cstddef>
|
|
#include <map>
|
|
#include <string>
|
|
|
|
|
|
#include "lib/backends/imgui_impl_opengl3.h"
|
|
#include "lib/backends/imgui_impl_sdl2.h"
|
|
#include "lib/imgui.h"
|
|
#include "lib/imgui_internal.h"
|
|
#include <cstdint>
|
|
#include <exiv2/tags.hpp>
|
|
#include <exiv2/version.hpp>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
#include <stdio.h>
|
|
#include <fstream>
|
|
|
|
#define STB_IMAGE_IMPLEMENTATION
|
|
#include "lib/stb_image.h"
|
|
#include <libraw/libraw.h>
|
|
|
|
#if defined(__APPLE__)
|
|
#include <SDL2/SDL.h>
|
|
#if defined(IMGUI_IMPL_OPENGL_ES2)
|
|
#include <SDL2/SDL_opengles.h>
|
|
#else
|
|
#include <SDL2/SDL_opengl.h>
|
|
#endif
|
|
#else
|
|
#include <SDL2/SDL.h>
|
|
#if defined(IMGUI_IMPL_OPENGL_ES2)
|
|
#include <SDL2/SDL_opengles2.h>
|
|
#else
|
|
#include <SDL2/SDL_opengl.h>
|
|
#endif
|
|
#endif
|
|
|
|
#include "lib/imgui_tex_inspect.h"
|
|
#include "lib/backends/tex_inspect_opengl.h"
|
|
#include "lib/argparse.hpp"
|
|
|
|
#include <exiv2/exiv2.hpp>
|
|
|
|
#include "lib/histogram.h"
|
|
#include <future>
|
|
#include <vector>
|
|
#include <filesystem>
|
|
#include <algorithm>
|
|
#include <execinfo.h>
|
|
#include <signal.h>
|
|
struct Args : public argparse::Args {
|
|
std::string &fpath = arg("path to the image");
|
|
};
|
|
|
|
struct EXIFData {
|
|
std::map<std::string, std::string> all_fields;
|
|
std::string CameraMake;
|
|
std::string CameraModel;
|
|
std::string LensModel;
|
|
std::string ImageOrientation;
|
|
std::string ImageDimensionX;
|
|
std::string ImageDimensiony;
|
|
std::string ISO;
|
|
std::string ShutterSpeed;
|
|
std::string FNumber;
|
|
std::string FocalLength;
|
|
std::string ExposureBias;
|
|
std::string MeteringMode;
|
|
std::string Flash;
|
|
std::string Time;
|
|
std::string TimeTaken;
|
|
std::string TimeTakenOffset;
|
|
std::string GPSLat;
|
|
std::string GPSLatref;
|
|
std::string GPSLon;
|
|
std::string GPSLonref;
|
|
};
|
|
|
|
struct Texture
|
|
{
|
|
ImTextureID texture;
|
|
ImVec2 size;
|
|
int channels;
|
|
EXIFData exif;
|
|
};
|
|
|
|
enum class DetectedFileType
|
|
{
|
|
RAW,
|
|
JPEG,
|
|
PNG,
|
|
TIFF,
|
|
UNKNOWN
|
|
};
|
|
|
|
void handler(int sig) {
|
|
void *array[10];
|
|
size_t size;
|
|
|
|
// get void*'s for all entries on the stack
|
|
size = backtrace(array, 10);
|
|
|
|
// print out all the frames to stderr
|
|
fprintf(stderr, "Error: signal %d:\n", sig);
|
|
backtrace_symbols_fd(array, size, STDERR_FILENO);
|
|
exit(1);
|
|
}
|
|
|
|
static uint8_t* image = nullptr;
|
|
static std::vector<std::string> image_files;
|
|
static int current_image_index = -1;
|
|
|
|
static DetectedFileType detectFileType(const std::string &filePath)
|
|
{
|
|
std::ifstream file(filePath, std::ios::binary);
|
|
if (!file)
|
|
return DetectedFileType::UNKNOWN;
|
|
|
|
unsigned char magic[12]; // Read enough bytes for common signatures
|
|
file.read(reinterpret_cast<char *>(magic), sizeof(magic));
|
|
if (!file)
|
|
return DetectedFileType::UNKNOWN;
|
|
|
|
// Check common signatures
|
|
if (magic[0] == 0xFF && magic[1] == 0xD8 && magic[2] == 0xFF)
|
|
return DetectedFileType::JPEG;
|
|
if (magic[0] == 0x89 && magic[1] == 'P' && magic[2] == 'N' && magic[3] == 'G')
|
|
return DetectedFileType::PNG;
|
|
if ((magic[0] == 'I' && magic[1] == 'I' && magic[2] == 0x2A && magic[3] == 0x00) || // Little-endian TIFF
|
|
(magic[0] == 'M' && magic[1] == 'M' && magic[2] == 0x00 && magic[3] == 0x2A)) // Big-endian TIFF
|
|
{
|
|
|
|
size_t dotPos = filePath.rfind('.');
|
|
if (dotPos != std::string::npos)
|
|
{
|
|
std::string ext = filePath.substr(dotPos);
|
|
std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
|
|
|
|
// Common RAW formats that use TIFF structure
|
|
const char *rawTiffExtensions[] = {
|
|
".nef", // Nikon
|
|
".cr2", // Canon
|
|
".dng", // Adobe/Various
|
|
".arw", // Sony
|
|
".srw", // Samsung
|
|
".orf", // Olympus
|
|
".pef", // Pentax
|
|
".raf", // Fuji
|
|
".rw2" // Panasonic
|
|
};
|
|
|
|
for (const char *rawExt : rawTiffExtensions)
|
|
{
|
|
if (ext == rawExt)
|
|
return DetectedFileType::RAW;
|
|
}
|
|
}
|
|
return DetectedFileType::TIFF;
|
|
}
|
|
|
|
// If no standard signature matches, check extension for RAW as a fallback
|
|
// (LibRaw handles many internal variations)
|
|
size_t dotPos = filePath.rfind('.');
|
|
if (dotPos != std::string::npos)
|
|
{
|
|
std::string ext = filePath.substr(dotPos);
|
|
std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
|
|
const char *rawExtensions[] = {
|
|
".3fr", ".ari", ".arw", ".bay", ".braw", ".crw", ".cr2", ".cr3", ".cap",
|
|
".data", ".dcs", ".dcr", ".dng", ".drf", ".eip", ".erf", ".fff", ".gpr",
|
|
".iiq", ".k25", ".kdc", ".mdc", ".mef", ".mos", ".mrw", ".nef", ".nrw",
|
|
".obm", ".orf", ".pef", ".ptx", ".pxn", ".r3d", ".raf", ".raw", ".rwl",
|
|
".rw2", ".rwz", ".sr2", ".srf", ".srw", ".tif", ".x3f" // Note: .tif can be RAW or regular TIFF
|
|
};
|
|
for (const char *rawExt : rawExtensions)
|
|
{
|
|
if (ext == rawExt)
|
|
return DetectedFileType::RAW;
|
|
}
|
|
// Special case: Leica .dng can also be loaded by LibRaw
|
|
if (ext == ".dng")
|
|
return DetectedFileType::RAW;
|
|
}
|
|
|
|
return DetectedFileType::UNKNOWN;
|
|
}
|
|
|
|
|
|
EXIFData printExifData(const std::string& imagePath) {
|
|
EXIFData d;
|
|
d.CameraMake = "NULL";
|
|
try {
|
|
// Load the image
|
|
#if EXIV2_TEST_VERSION(0,28,0)
|
|
Exiv2::Image::UniquePtr img = Exiv2::ImageFactory::open(imagePath);
|
|
#else
|
|
Exiv2::Image::AutoPtr img = Exiv2::ImageFactory::open(imagePath);
|
|
#endif
|
|
if (img.get() == 0) {
|
|
std::cerr << "Error: Could not open image file " << imagePath << std::endl;
|
|
return d;
|
|
}
|
|
img->readMetadata();
|
|
|
|
// Get the Exif data
|
|
Exiv2::ExifData &exifData = img->exifData();
|
|
if (exifData.empty()) {
|
|
std::cerr << "No EXIF data found in file " << imagePath << std::endl;
|
|
return d;
|
|
}
|
|
|
|
for (auto i = exifData.begin(); i != exifData.end(); ++i) {
|
|
d.all_fields[i->key()] = i->value().toString();
|
|
}
|
|
|
|
// Helper function to print EXIF data if available
|
|
auto printExifValue = [&exifData](const char* key, std::string *d) {
|
|
Exiv2::ExifKey exifKey(key);
|
|
Exiv2::ExifData::const_iterator pos = exifData.findKey(exifKey);
|
|
if (pos != exifData.end()) {
|
|
*d = pos->value().toString();
|
|
}
|
|
};
|
|
|
|
// Print common EXIF data
|
|
printExifValue("Exif.Image.Make", &d.CameraMake);
|
|
printExifValue("Exif.Image.Model", &d.CameraModel);
|
|
printExifValue("Exif.Photo.LensModel", &d.LensModel);
|
|
|
|
printExifValue("Exif.Image.Orientation", &d.ImageOrientation);
|
|
//
|
|
printExifValue("Exif.Photo.ExposureTime", &d.ShutterSpeed);
|
|
printExifValue("Exif.Photo.FNumber", &d.FNumber);
|
|
printExifValue("Exif.Photo.ISOSpeedRatings", &d.ISO);
|
|
printExifValue("Exif.Photo.FocalLength", &d.FocalLength);
|
|
printExifValue("Exif.Photo.ExposureBiasValue", &d.ExposureBias);
|
|
printExifValue("Exif.Photo.MeteringMode", &d.MeteringMode);
|
|
printExifValue("Exif.Photo.Flash", &d.Flash);
|
|
|
|
printExifValue("Exif.Image.DateTime", &d.Time);
|
|
printExifValue("Exif.Photo.DateTimeOriginal", &d.TimeTaken);
|
|
printExifValue("Exif.Photo.OffsetTime", &d.TimeTakenOffset);
|
|
printExifValue("Exif.Photo.PixelXDimension", &d.ImageDimensionX);
|
|
printExifValue("Exif.Photo.PixelYDimension", &d.ImageDimensiony);
|
|
|
|
printExifValue("Exif.GPSInfo.GPSLatitudeRef", &d.GPSLatref);
|
|
printExifValue("Exif.GPSInfo.GPSLatitude", &d.GPSLat);
|
|
printExifValue("Exif.GPSInfo.GPSLongitudeRef", &d.GPSLonref);
|
|
printExifValue("Exif.GPSInfo.GPSLongitude", &d.GPSLon);
|
|
|
|
|
|
/*
|
|
Exif.Image.Make 0x010f Ascii 5 SONY
|
|
Exif.Image.Model 0x0110 Ascii 10 ILCE-7RM5
|
|
|
|
Exif.Image.Orientation 0x0112 Short 1 8
|
|
Exif.Photo.PixelXDimension 0xa002 Long 1 9504
|
|
Exif.Photo.PixelYDimension 0xa003 Long 1 6336
|
|
|
|
Exif.Photo.ExposureTime 0x829a Rational 1 1/400
|
|
Exif.Photo.FNumber 0x829d Rational 1 56/10
|
|
Exif.Photo.ISOSpeedRatings 0x8827 Short 1 100
|
|
Exif.Photo.FocalLength 0x920a Rational 1 400/10
|
|
Exif.Photo.ExposureBiasValue 0x9204 SRational 1 -10/10
|
|
Exif.Photo.MeteringMode 0x9207 Short 1 5
|
|
Exif.Photo.Flash 0x9209 Short 1 16
|
|
|
|
Exif.Image.DateTime 0x0132 Ascii 20 2024:06:07 08:58:07
|
|
Exif.Photo.DateTimeOriginal 0x9003 Ascii 20 2024:06:07 08:58:07
|
|
Exif.Photo.OffsetTime 0x9010 Ascii 7 -05:00
|
|
|
|
Exif.GPSInfo.GPSLatitudeRef 0x0001 Ascii 2 N
|
|
Exif.GPSInfo.GPSLatitude 0x0002 Rational 3 40/1 43/1 32231/1000
|
|
Exif.GPSInfo.GPSLongitudeRef 0x0003 Ascii 2 W
|
|
Exif.GPSInfo.GPSLongitude 0x0004 Rational 3 73/1 59/1 16688/1000
|
|
*/
|
|
|
|
} catch (Exiv2::Error& e) {
|
|
std::cerr << "Error: " << e.what() << std::endl;
|
|
}
|
|
|
|
return d;
|
|
}
|
|
|
|
Texture ReloadTexture(Texture tin, int width, int height) {
|
|
GLuint tid = (GLuint)(uintptr_t)tin.texture;
|
|
glDeleteTextures((GLsizei)1, &tid);
|
|
|
|
GLenum dataFormat = GL_RGBA;
|
|
GLuint textureHandle;
|
|
glGenTextures(1, &textureHandle);
|
|
glBindTexture(GL_TEXTURE_2D, textureHandle);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, dataFormat, GL_UNSIGNED_BYTE, image);
|
|
|
|
Texture t;
|
|
t.texture = (void*)(uintptr_t)(textureHandle);
|
|
t.size = ImVec2((float)width,(float)height);
|
|
t.exif = tin.exif;
|
|
t.channels = tin.channels;
|
|
|
|
return t;
|
|
}
|
|
|
|
void RotateImage(Texture t) {
|
|
int height = t.size.y;
|
|
int width = t.size.x;
|
|
int channels = t.channels;
|
|
|
|
const unsigned int sizeBuffer = width * height * channels;
|
|
unsigned char *tempBuffer = new unsigned char[sizeBuffer];
|
|
|
|
int nidx = 0;
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
for (int y = height - 1; y >= 0; y--)
|
|
{
|
|
int idx = (x + y * width) * channels;
|
|
for (int i = 0; i < channels; i++)
|
|
tempBuffer[nidx + i] = image[idx + i];
|
|
|
|
nidx = nidx + 4;
|
|
}
|
|
}
|
|
|
|
memcpy(image, tempBuffer, sizeBuffer);
|
|
delete[] tempBuffer;
|
|
}
|
|
|
|
Texture LoadImage(const char * path) {
|
|
const int channelCount = 4;
|
|
int imageFileChannelCount;
|
|
int width, height;
|
|
|
|
// Detect File type
|
|
DetectedFileType fileType = detectFileType(path);
|
|
|
|
if (fileType == DetectedFileType::RAW) {
|
|
LibRaw iProcessor;
|
|
iProcessor.open_file(path);
|
|
iProcessor.unpack();
|
|
iProcessor.imgdata.params.use_camera_wb = 1;
|
|
iProcessor.dcraw_process();
|
|
|
|
libraw_processed_image_t *processed_image = iProcessor.dcraw_make_mem_image();
|
|
if (processed_image == NULL) {
|
|
fprintf(stderr, "Failed to process RAW file %s\n", path);
|
|
return {nullptr,{0,0}};
|
|
}
|
|
|
|
width = processed_image->width;
|
|
height = processed_image->height;
|
|
imageFileChannelCount = processed_image->colors;
|
|
|
|
image = new uint8_t[width * height * channelCount];
|
|
|
|
if (processed_image->bits == 16) {
|
|
for (int i = 0; i < width * height; ++i) {
|
|
image[i * channelCount + 0] = processed_image->data[i * imageFileChannelCount + 0] / 256;
|
|
image[i * channelCount + 1] = processed_image->data[i * imageFileChannelCount + 1] / 256;
|
|
image[i * channelCount + 2] = processed_image->data[i * imageFileChannelCount + 2] / 256;
|
|
image[i * channelCount + 3] = 255; // Alpha channel
|
|
}
|
|
} else { // 8-bit
|
|
for (int i = 0; i < width * height; ++i) {
|
|
image[i * channelCount + 0] = processed_image->data[i * imageFileChannelCount + 0];
|
|
image[i * channelCount + 1] = processed_image->data[i * imageFileChannelCount + 1];
|
|
image[i * channelCount + 2] = processed_image->data[i * imageFileChannelCount + 2];
|
|
image[i * channelCount + 3] = 255; // Alpha channel
|
|
}
|
|
}
|
|
|
|
iProcessor.dcraw_clear_mem(processed_image);
|
|
|
|
} else {
|
|
image = (uint8_t *)stbi_load(path, &width, &height, &imageFileChannelCount, channelCount);
|
|
if (image == NULL) {
|
|
fprintf(stderr, "%s\nFailed to open %s\n", stbi_failure_reason(), path);
|
|
return {nullptr,{0,0}};
|
|
}
|
|
}
|
|
auto exif = printExifData(path);
|
|
|
|
Texture t;
|
|
t.size = ImVec2((float)width,(float)height);
|
|
t.channels = channelCount;
|
|
t.exif = exif;
|
|
return t;
|
|
}
|
|
|
|
Texture LoadTexture(Texture tin) {
|
|
GLenum dataFormat = GL_RGBA;
|
|
GLuint textureHandle;
|
|
glGenTextures(1, &textureHandle);
|
|
glBindTexture(GL_TEXTURE_2D, textureHandle);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tin.size.x, tin.size.y, 0, dataFormat, GL_UNSIGNED_BYTE, image);
|
|
|
|
Texture t = tin;
|
|
t.texture = (void*)(uintptr_t)(textureHandle);
|
|
|
|
if (t.exif.ImageOrientation == "3") {
|
|
RotateImage(t);
|
|
ReloadTexture(t, t.size.x, t.size.y);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
RotateImage(t);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
} else if (t.exif.ImageOrientation == "6") {
|
|
RotateImage(t);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
} else if (t.exif.ImageOrientation == "8") {
|
|
RotateImage(t);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
RotateImage(t);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
RotateImage(t);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
}
|
|
|
|
return t;
|
|
}
|
|
|
|
|
|
const int MAX_ANNOATED_TEXELS = 10000;
|
|
|
|
// Main code
|
|
int main(int argc, char* argv[]) {
|
|
signal(SIGSEGV, handler);
|
|
Texture t;
|
|
std::string current_fpath;
|
|
|
|
try {
|
|
auto args = argparse::parse<Args>(argc, argv, true);
|
|
current_fpath = args.fpath;
|
|
t = LoadImage(current_fpath.c_str());
|
|
if (t.texture == nullptr) {
|
|
std::cerr << "failed load image" << std::endl;
|
|
return -1;
|
|
}
|
|
} catch (const std::runtime_error &e) {
|
|
std::cerr << "failed to parse arguments: " << e.what() << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
std::filesystem::path p(current_fpath);
|
|
auto parent_path = p.parent_path();
|
|
for (const auto& entry : std::filesystem::directory_iterator(parent_path)) {
|
|
if (entry.is_regular_file()) {
|
|
if (detectFileType(entry.path().string()) != DetectedFileType::UNKNOWN) {
|
|
image_files.push_back(entry.path().string());
|
|
}
|
|
}
|
|
}
|
|
std::sort(image_files.begin(), image_files.end());
|
|
auto it = std::find(image_files.begin(), image_files.end(), current_fpath);
|
|
if (it != image_files.end()) {
|
|
current_image_index = std::distance(image_files.begin(), it);
|
|
}
|
|
// Setup SDL
|
|
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_GAMECONTROLLER) !=
|
|
0) {
|
|
printf("Error: %s\n", SDL_GetError());
|
|
return -1;
|
|
}
|
|
|
|
bool TOOLTIP_ENABLED = false;
|
|
bool GRID_ENABLED = false;
|
|
bool AA_ENABLED = true;
|
|
bool SHOW_HELP = false;
|
|
bool SHOW_EXIF = false;
|
|
bool SHOW_HISTOGRAM = false;
|
|
int MODE = 0;
|
|
bool histogram_ready = false;
|
|
std::future<Texture> image_load_future;
|
|
|
|
// Decide GL+GLSL versions
|
|
#if defined(IMGUI_IMPL_OPENGL_ES2)
|
|
// GL ES 2.0 + GLSL 100
|
|
const char *glsl_version = "#version 100";
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
|
|
#elif defined(__APPLE__)
|
|
// GL 3.2 Core + GLSL 150
|
|
const char *glsl_version = "#version 150";
|
|
SDL_GL_SetAttribute(
|
|
SDL_GL_CONTEXT_FLAGS,
|
|
SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG); // Always required on Mac
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
|
|
#else
|
|
// GL 3.0 + GLSL 130
|
|
const char *glsl_version = "#version 130";
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, 0);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
|
|
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
|
|
#endif
|
|
|
|
// From 2.0.18: Enable native IME.
|
|
#ifdef SDL_HINT_IME_SHOW_UI
|
|
SDL_SetHint(SDL_HINT_IME_SHOW_UI, "1");
|
|
#endif
|
|
|
|
// Create window with graphics context
|
|
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
|
|
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
|
|
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
|
|
SDL_WindowFlags window_flags =
|
|
(SDL_WindowFlags)(SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE |
|
|
SDL_WINDOW_ALLOW_HIGHDPI);
|
|
|
|
float image_w = t.size.x;
|
|
float image_h = t.size.y;
|
|
if (t.exif.ImageOrientation == "6" || t.exif.ImageOrientation == "8") {
|
|
std::swap(image_w, image_h);
|
|
}
|
|
|
|
float aspect_ratio = image_w / image_h;
|
|
int viewer_h = image_h;
|
|
int viewer_w = image_w;
|
|
const int max_h = 1200;
|
|
|
|
if (viewer_h > max_h) {
|
|
viewer_h = max_h;
|
|
viewer_w = max_h * aspect_ratio;
|
|
}
|
|
|
|
int ww = viewer_w * 1.25;
|
|
int wh = viewer_h * 1.25;
|
|
|
|
SDL_Window *window =
|
|
SDL_CreateWindow("tview", SDL_WINDOWPOS_CENTERED,
|
|
SDL_WINDOWPOS_CENTERED, ww, wh, window_flags);
|
|
if (window == nullptr) {
|
|
printf("Error: SDL_CreateWindow(): %s\n", SDL_GetError());
|
|
return -1;
|
|
}
|
|
|
|
SDL_GLContext gl_context = SDL_GL_CreateContext(window);
|
|
SDL_GL_MakeCurrent(window, gl_context);
|
|
SDL_GL_SetSwapInterval(1); // Enable vsync
|
|
|
|
|
|
// Setup Dear ImGui context
|
|
IMGUI_CHECKVERSION();
|
|
|
|
|
|
ImGui::CreateContext();
|
|
ImGuiIO &io = ImGui::GetIO();
|
|
ImGui::GetIO().IniFilename = NULL;
|
|
(void)io;
|
|
io.ConfigFlags |=
|
|
ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
|
|
ImGuiTexInspect::ImplOpenGL3_Init(); // Or DirectX 11 equivalent (check your chosen backend header file)
|
|
ImGuiTexInspect::Init();
|
|
ImGuiTexInspect::CreateContext();
|
|
ImGui::StyleColorsDark();
|
|
ImGuiStyle &style = ImGui::GetStyle();
|
|
ImGui_ImplSDL2_InitForOpenGL(window, gl_context);
|
|
ImGui_ImplOpenGL3_Init(glsl_version);
|
|
|
|
ImVec4 clear_color = ImVec4(0.18f, 0.18f, 0.18f, 1.00f);
|
|
std::vector<ImVec4> background_colors = {
|
|
ImVec4(0.0f, 0.0f, 0.0f, 1.00f),
|
|
ImVec4(0.18f, 0.18f, 0.18f, 1.00f),
|
|
ImVec4(0.5f, 0.5f, 0.5f, 1.00f),
|
|
ImVec4(255.0f, 255.0f, 255.0f, 255.00f),
|
|
ImVec4(0.75f, 0.75f, 0.75f, 1.00f)
|
|
};
|
|
int background_color_index = 1;
|
|
|
|
auto flags = ImGuiTexInspect::InspectorFlags_FillVertical | ImGuiTexInspect::InspectorFlags_FillHorizontal;
|
|
|
|
t = LoadTexture(t);
|
|
ImGuiTexInspect::SetInitialZoom(0.80f);
|
|
Histogram histogram = Histogram(t.size.x, t.size.y, t.channels);
|
|
auto histogram_future = std::async(std::launch::async, [&]() {
|
|
histogram.Load(image);
|
|
histogram_ready = true;
|
|
});
|
|
|
|
// Main loop
|
|
bool done = false;
|
|
while (!done)
|
|
{
|
|
if (image_load_future.valid()) {
|
|
auto status = image_load_future.wait_for(std::chrono::seconds(0));
|
|
if (status == std::future_status::ready) {
|
|
auto new_texture_data = image_load_future.get();
|
|
GLuint textureID = (GLuint)(uintptr_t)t.texture;
|
|
glDeleteTextures(1, &textureID);
|
|
t = new_texture_data;
|
|
t = LoadTexture(t);
|
|
histogram = Histogram(t.size.x, t.size.y, t.channels);
|
|
histogram_ready = false;
|
|
histogram_future = std::async(std::launch::async, [&]() {
|
|
histogram.Load(image);
|
|
histogram_ready = true;
|
|
});
|
|
}
|
|
}
|
|
|
|
// Poll and handle events (inputs, window resize, etc.)
|
|
SDL_Event event;
|
|
while (SDL_PollEvent(&event)) {
|
|
ImGui_ImplSDL2_ProcessEvent(&event);
|
|
if (event.type == SDL_WINDOWEVENT &&
|
|
event.window.event == SDL_WINDOWEVENT_CLOSE &&
|
|
event.window.windowID == SDL_GetWindowID(window))
|
|
done = true;
|
|
|
|
switch (event.type) {
|
|
case SDL_QUIT:
|
|
|
|
case SDL_KEYDOWN:
|
|
switch (event.key.keysym.scancode) {
|
|
case SDL_SCANCODE_G:
|
|
|
|
GRID_ENABLED = !GRID_ENABLED;
|
|
break;
|
|
case SDL_SCANCODE_T:
|
|
TOOLTIP_ENABLED = !TOOLTIP_ENABLED;
|
|
break;
|
|
case SDL_SCANCODE_A:
|
|
AA_ENABLED = !AA_ENABLED;
|
|
break;
|
|
case SDL_SCANCODE_SLASH:
|
|
SHOW_HELP = !SHOW_HELP;
|
|
break;
|
|
case SDL_SCANCODE_D:
|
|
MODE = (MODE + 1) % 5;
|
|
break;
|
|
case SDL_SCANCODE_R:
|
|
RotateImage(t);
|
|
t = ReloadTexture(t, t.size.y, t.size.x);
|
|
break;
|
|
case SDL_SCANCODE_Q:
|
|
done = true;
|
|
break;
|
|
case SDL_SCANCODE_E:
|
|
SHOW_EXIF = !SHOW_EXIF;
|
|
break;
|
|
case SDL_SCANCODE_H:
|
|
SHOW_HISTOGRAM = !SHOW_HISTOGRAM;
|
|
break;
|
|
case SDL_SCANCODE_B:
|
|
background_color_index = (background_color_index + 1) % background_colors.size();
|
|
clear_color = background_colors[background_color_index];
|
|
break;
|
|
case SDL_SCANCODE_LEFT:
|
|
if (current_image_index > 0) {
|
|
current_image_index--;
|
|
} else {
|
|
current_image_index = image_files.size() - 1;
|
|
}
|
|
if (!image_load_future.valid() || image_load_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
|
|
image_load_future = std::async(std::launch::async, [&]() {
|
|
return LoadImage(image_files[current_image_index].c_str());
|
|
});
|
|
}
|
|
break;
|
|
case SDL_SCANCODE_RIGHT:
|
|
if (current_image_index < (int)image_files.size() - 1) {
|
|
current_image_index++;
|
|
} else {
|
|
current_image_index = 0;
|
|
}
|
|
if (!image_load_future.valid() || image_load_future.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
|
|
image_load_future = std::async(std::launch::async, [&]() {
|
|
return LoadImage(image_files[current_image_index].c_str());
|
|
});
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start the Dear ImGui frame
|
|
ImGui_ImplOpenGL3_NewFrame();
|
|
ImGui_ImplSDL2_NewFrame();
|
|
ImGui::NewFrame();
|
|
{
|
|
#ifdef IMGUI_HAS_VIEWPORT
|
|
ImGuiViewport *viewport = ImGui::GetMainViewport();
|
|
ImGui::SetNextWindowPos(viewport->WorkPos);
|
|
ImGui::SetNextWindowSize(viewport->WorkSize);
|
|
ImGui::SetNextWindowViewport(viewport->ID);
|
|
#else
|
|
ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f));
|
|
ImGui::SetNextWindowSize(ImGui::GetIO().DisplaySize);
|
|
#endif
|
|
|
|
|
|
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
|
|
ImGui::SetNextWindowPos(viewport->Pos);
|
|
ImGui::SetNextWindowSize(viewport->Size);
|
|
ImGui::Begin("Main", NULL,
|
|
ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoBringToFrontOnFocus);
|
|
auto wSize = ImGui::GetContentRegionAvail();
|
|
if (t.texture != 0) {
|
|
|
|
if (!TOOLTIP_ENABLED) {
|
|
flags = flags | ImGuiTexInspect::InspectorFlags_NoTooltip;
|
|
}
|
|
|
|
ImGuiTexInspect::BeginInspectorPanel(
|
|
"Inspector",
|
|
t.texture,
|
|
t.size,
|
|
flags,
|
|
ImGuiTexInspect::SizeExcludingBorder(wSize)
|
|
);
|
|
|
|
CurrentInspector_SetAlphaMode(
|
|
ImGuiTexInspect::InspectorAlphaMode_CustomColor
|
|
);
|
|
ImGuiTexInspect::CurrentInspector_SetCustomBackgroundColor(clear_color);
|
|
|
|
if (GRID_ENABLED) {
|
|
CurrentInspector_ClearFlags(ImGuiTexInspect::InspectorFlags_NoGrid);
|
|
}else {
|
|
CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoGrid);
|
|
}
|
|
|
|
if (TOOLTIP_ENABLED) {
|
|
CurrentInspector_ClearFlags(ImGuiTexInspect::InspectorFlags_NoTooltip);
|
|
}else {
|
|
CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoTooltip);
|
|
}
|
|
|
|
if (AA_ENABLED) {
|
|
CurrentInspector_ClearFlags(ImGuiTexInspect::InspectorFlags_NoForceFilterNearest);
|
|
}else {
|
|
CurrentInspector_SetFlags(ImGuiTexInspect::InspectorFlags_NoForceFilterNearest);
|
|
}
|
|
|
|
switch(MODE) {
|
|
case 1:
|
|
ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::Arrow().UsePreset(ImGuiTexInspect::Arrow::NormalMap), MAX_ANNOATED_TEXELS);
|
|
break;
|
|
case 2:
|
|
ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::HexString), MAX_ANNOATED_TEXELS);
|
|
break;
|
|
case 3:
|
|
ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::BytesDec), MAX_ANNOATED_TEXELS);
|
|
break;
|
|
case 4:
|
|
ImGuiTexInspect::DrawAnnotations(ImGuiTexInspect::ValueText(ImGuiTexInspect::ValueText::Format::Floats), MAX_ANNOATED_TEXELS);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
|
|
ImGuiTexInspect::EndInspectorPanel();
|
|
}
|
|
ImGui::End();
|
|
ImGui::PopStyleVar();
|
|
ImGui::PopStyleVar();
|
|
|
|
if (SHOW_HELP){
|
|
ImGui::OpenPopup("HelpPopup");
|
|
SHOW_HELP = !SHOW_HELP;
|
|
}
|
|
|
|
if (ImGui::BeginPopup("HelpPopup")) {
|
|
ImGui::Text("tview Help");
|
|
ImGui::Separator();
|
|
ImGui::Text("b - cycle background color");
|
|
ImGui::Text("r - rotate 90 deg clockwise");
|
|
ImGui::Text("g - toggle grid");
|
|
ImGui::Text("a - toggle filtering");
|
|
ImGui::Text("t - toggle tooltip");
|
|
ImGui::Text("d - cycle pixel detail mode");
|
|
ImGui::Separator();
|
|
ImGui::Text("modes:");
|
|
ImGui::Text(" Off");
|
|
ImGui::Text(" Gradient Arrow");
|
|
ImGui::Text(" Hex Code");
|
|
ImGui::Text(" RGB Values");
|
|
ImGui::Text(" Float Values");
|
|
ImGui::Separator();
|
|
ImGui::Text("? - show help popup");
|
|
ImGui::Text("h - toggle color histogram");
|
|
ImGui::Text("e - toggle EXIF info");
|
|
ImGui::Separator();
|
|
ImGui::Text("q - quit");
|
|
ImGui::Separator();
|
|
ImGui::Text("click anywhere to continue");
|
|
ImGui::EndPopup();
|
|
}
|
|
if (SHOW_EXIF) {
|
|
if (t.exif.CameraMake != "NULL") {
|
|
ImGuiWindowClass topmost;
|
|
topmost.ClassId = ImHashStr("TopMost");
|
|
topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
|
|
ImGui::SetNextWindowClass(&topmost);
|
|
ImGui::SetNextWindowSize(ImVec2(600, 600), ImGuiCond_FirstUseEver);
|
|
ImGui::Begin("EXIF", &SHOW_EXIF, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoFocusOnAppearing);
|
|
if(ImGui::BeginTable("Hardware", 2, ImGuiTableFlags_Resizable)) {
|
|
ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
|
|
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Make");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.CameraMake.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Model");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.CameraModel.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Lens");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.LensModel.c_str());
|
|
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
if(ImGui::BeginTable("Photo", 2, ImGuiTableFlags_Resizable)) {
|
|
ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
|
|
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Shutter Speed");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.ShutterSpeed.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("F-Stop");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.FNumber.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("ISO");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.ISO.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Focal Length");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.FocalLength.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Exposure Comp");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.ExposureBias.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Metering Mode");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.MeteringMode.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Flash");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.Flash.c_str());
|
|
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
if(ImGui::BeginTable("Meta", 2, ImGuiTableFlags_Resizable)) {
|
|
ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
|
|
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Date");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s %s", t.exif.TimeTaken.c_str(), t.exif.TimeTakenOffset.c_str());
|
|
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Dimensions");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%sx%s", t.exif.ImageDimensionX.c_str(), t.exif.ImageDimensiony.c_str());
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Orientation");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", t.exif.ImageOrientation.c_str());
|
|
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
if(ImGui::BeginTable("Location", 2, ImGuiTableFlags_Resizable)) {
|
|
ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
|
|
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Latitude");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s %s", t.exif.GPSLat.c_str(), t.exif.GPSLatref.c_str());
|
|
|
|
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("Longitude");
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s %s", t.exif.GPSLon.c_str(), t.exif.GPSLonref.c_str());
|
|
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
if(ImGui::BeginTable("All EXIF", 2, ImGuiTableFlags_Resizable)) {
|
|
ImGui::TableSetupColumn("Field", ImGuiTableColumnFlags_WidthFixed, ImGuiTableColumnFlags_NoHide, 150.0f);
|
|
ImGui::TableSetupColumn("Value", ImGuiTableColumnFlags_WidthStretch);
|
|
for (auto const& [key, val] : t.exif.all_fields)
|
|
{
|
|
ImGui::TableNextRow();
|
|
ImGui::TableSetColumnIndex(0);
|
|
ImGui::TextWrapped("%s", key.c_str());
|
|
ImGui::TableSetColumnIndex(1);
|
|
ImGui::TextWrapped("%s", val.c_str());
|
|
}
|
|
ImGui::EndTable();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
ImGui::Text("Press e to hide");
|
|
|
|
ImGui::End();
|
|
} else {
|
|
ImGuiWindowClass topmost;
|
|
topmost.ClassId = ImHashStr("TopMost");
|
|
topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
|
|
ImGui::SetNextWindowClass(&topmost);
|
|
ImGui::SetNextWindowSize(ImVec2(200, 50), ImGuiCond_FirstUseEver);
|
|
ImGui::Begin("EXIF", &SHOW_EXIF, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_AlwaysAutoResize);
|
|
ImGui::Text("No EXIF data available.");
|
|
ImGui::End();
|
|
}
|
|
}
|
|
|
|
|
|
if (SHOW_HISTOGRAM) {
|
|
ImGuiWindowClass topmost;
|
|
topmost.ClassId = ImHashStr("TopMost");
|
|
topmost.ViewportFlagsOverrideSet = ImGuiViewportFlags_TopMost;
|
|
ImGui::SetNextWindowClass(&topmost);
|
|
ImGui::Begin("Histogram", NULL, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoFocusOnAppearing);
|
|
if (histogram_ready) {
|
|
histogram.Draw();
|
|
ImGui::Separator();
|
|
ImGui::Text("Press c to hide");
|
|
} else {
|
|
ImGui::Text("Loading...");
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
}
|
|
|
|
|
|
// Rendering
|
|
ImGui::Render();
|
|
glViewport(0, 0, (int)io.DisplaySize.x, (int)io.DisplaySize.y);
|
|
glClearColor(clear_color.x, clear_color.y, clear_color.z, clear_color.w);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
|
|
SDL_GL_SwapWindow(window);
|
|
}
|
|
|
|
if (image != nullptr) {
|
|
stbi_image_free(image);
|
|
}
|
|
|
|
// Cleanup
|
|
ImGui_ImplOpenGL3_Shutdown();
|
|
ImGui_ImplSDL2_Shutdown();
|
|
ImGui::DestroyContext();
|
|
|
|
SDL_GL_DeleteContext(gl_context);
|
|
SDL_DestroyWindow(window);
|
|
SDL_Quit();
|
|
|
|
return 0;
|
|
}
|