92 行
4.9 KiB
Plaintext
92 行
4.9 KiB
Plaintext
#import "DYAutoGrade.h"
|
|
#import "DYColorTables.h"
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <vector>
|
|
|
|
// Quantized percentile-based automatic grading.
|
|
// Algorithm sources and historical evidence: research/ALGORITHM_SOURCES.md.
|
|
// The reference redraws NSImage into 320x180 UInt8 RGBA. Our renderer provides
|
|
// 320x180 float RGBA samples; quantization recreates that numerical domain.
|
|
// This does not claim byte-identical NSImage/CoreGraphics resampling.
|
|
#pragma clang fp contract(off)
|
|
|
|
namespace {
|
|
struct Samples {
|
|
std::vector<float> luma;
|
|
std::vector<float> saturation;
|
|
float neutralR=0, neutralG=0, neutralB=0, neutralWeight=0;
|
|
};
|
|
static float byteValue(float value) {
|
|
return std::round(std::clamp(value,0.f,1.f)*255.f)/255.f;
|
|
}
|
|
static bool gather(NSData *frame,Samples& samples) {
|
|
if(!frame || frame.length==0 || frame.length%(sizeof(float)*4)!=0)return false;
|
|
const float *pixels=(const float *)frame.bytes;
|
|
size_t count=frame.length/(sizeof(float)*4);
|
|
samples.luma.reserve(count);samples.saturation.reserve(count);
|
|
for(size_t i=0;i<count;++i) {
|
|
const float *p=pixels+i*4;
|
|
if(!std::isfinite(p[0])||!std::isfinite(p[1])||!std::isfinite(p[2])||!std::isfinite(p[3]))continue;
|
|
if(std::round(std::clamp(p[3],0.f,1.f)*255.f)<=8.f)continue;
|
|
float r=byteValue(p[0]),g=byteValue(p[1]),b=byteValue(p[2]);
|
|
float maximum=std::max(r,std::max(g,b)),minimum=std::min(r,std::min(g,b));
|
|
float saturation=maximum>.001f?(maximum-minimum)/maximum:0.f;
|
|
float luma=(r*.2126f+g*.7152f)+b*.0722f;
|
|
samples.luma.push_back(luma);samples.saturation.push_back(saturation);
|
|
if(luma>.18f&&luma<.92f&&saturation<.16f&&maximum<.98f) {
|
|
float weight=std::max(0.f,.16f-saturation)/.16f*(std::min(luma,.55f)+.45f);
|
|
samples.neutralR+=r*weight;samples.neutralG+=g*weight;samples.neutralB+=b*weight;samples.neutralWeight+=weight;
|
|
}
|
|
}
|
|
return samples.luma.size()>=129;
|
|
}
|
|
static float percentile(const std::vector<float>& sorted,float fraction) {
|
|
size_t index=(size_t)std::round(std::clamp(fraction,0.f,1.f)*float(sorted.size()-1));
|
|
return sorted[std::min(index,sorted.size()-1)];
|
|
}
|
|
static double rounded(float value) {return std::round(double(value));}
|
|
}
|
|
|
|
NSDictionary<NSString *, NSNumber *> *DYAutoGrade(NSData *frame) {
|
|
Samples samples;if(!gather(frame,samples))return nil;
|
|
std::sort(samples.luma.begin(),samples.luma.end());
|
|
std::sort(samples.saturation.begin(),samples.saturation.end());
|
|
float p02=percentile(samples.luma,.02f),p05=percentile(samples.luma,.05f);
|
|
float p10=percentile(samples.luma,.10f),p50=percentile(samples.luma,.50f);
|
|
float p90=percentile(samples.luma,.90f),p95=percentile(samples.luma,.95f),p98=percentile(samples.luma,.98f);
|
|
float sumSaturation=0;for(float value:samples.saturation)sumSaturation+=value;
|
|
float meanSaturation=sumSaturation/float(samples.saturation.size());
|
|
float range=std::max(.001f,p95-p05);
|
|
float rawExposure=std::log2(.46f/std::max(p50,.05f))*.72f;
|
|
double exposure=std::round(std::clamp(double(rawExposure),-1.1,1.1)*100.0)/100.0;
|
|
float contrast=std::clamp((.7f-range)*82.f,-22.f,34.f);
|
|
double highlights=double(std::clamp((.84f-p95)*150.f,-55.f,26.f));
|
|
if(p90>.93f)highlights+=double((p90+(-.93f))*-25.f);
|
|
float shadows=std::clamp((.18f-p10)*180.f,-22.f,55.f);
|
|
float whites=std::clamp((.93f-p98)*92.f,-35.f,42.f);
|
|
float blacks=std::clamp((.045f-p02)*175.f,-36.f,24.f);
|
|
float vibrance=std::clamp((.28f-meanSaturation)*90.f,-8.f,28.f);
|
|
float saturation=std::clamp((.22f-meanSaturation)*42.f,-12.f,12.f);
|
|
double temperature=0,tint=0;
|
|
if(samples.neutralWeight>float(samples.luma.size())*.003f) {
|
|
float r=samples.neutralR/samples.neutralWeight,g=samples.neutralG/samples.neutralWeight,b=samples.neutralB/samples.neutralWeight;
|
|
double confidence=std::min(1.0,(double(samples.neutralWeight)/double(samples.luma.size()))*18.0);
|
|
temperature=std::clamp(double(b-r)*125.0*confidence,-36.0,36.0);
|
|
tint=std::clamp(double(g+(b+r)*-.5f)*120.0*confidence,-32.0,32.0);
|
|
}
|
|
return @{@"exposure":@(exposure),@"contrast":@(rounded(contrast)),@"highlights":@(std::round(highlights)),
|
|
@"shadows":@(rounded(shadows)),@"whites":@(rounded(whites)),@"blacks":@(rounded(blacks)),
|
|
@"vibrance":@(rounded(vibrance)),@"saturation":@(rounded(saturation)),
|
|
@"temperature":@(std::round(temperature)),@"tint":@(std::round(tint))};
|
|
}
|
|
|
|
NSDictionary<NSString *, NSNumber *> *DYAutoWhiteBalance(NSData *frame) {
|
|
Samples samples;if(!gather(frame,samples))return nil;
|
|
if(samples.neutralWeight<=float(samples.luma.size())*.003f)return nil;
|
|
vector_float3 neutral={samples.neutralR/samples.neutralWeight,samples.neutralG/samples.neutralWeight,samples.neutralB/samples.neutralWeight};
|
|
float temperature=0,tint=0;
|
|
if(![DYColorTables neutralizeColor:neutral temperature:&temperature tint:&tint])return nil;
|
|
return @{@"temperature":@(temperature),@"tint":@(tint)};
|
|
}
|