mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność

genesys: Remove no longer used coarse calibration ced path

merge-requests/340/head
Povilas Kanapickas 2020-02-17 00:49:14 +02:00
rodzic 9e3bf1e1e2
commit 4c395182be
14 zmienionych plików z 0 dodań i 508 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

2
backend/genesys/command_set.h
Wyświetl plik

@ -70,8 +70,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const = 0;
virtual void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const = 0;
virtual void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const = 0;
virtual void init_regs_for_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,

295
backend/genesys/genesys.cpp
Wyświetl plik

@ -1276,301 +1276,6 @@ void sanei_genesys_calculate_zmod(bool two_table,
*out_z2 = sum % exposure_time;
}
static uint8_t genesys_adjust_gain(double* applied_multi, double multi, uint8_t gain)
{
double voltage, original_voltage;
uint8_t new_gain = 0;
DBG(DBG_proc, "%s: multi=%f, gain=%d\n", __func__, multi, gain);
voltage = 0.5 + gain * 0.25;
original_voltage = voltage;
voltage *= multi;
new_gain = static_cast<std::uint8_t>((voltage - 0.5) * 4);
if (new_gain > 0x0e)
new_gain = 0x0e;
voltage = 0.5 + (new_gain) * 0.25;
*applied_multi = voltage / original_voltage;
DBG(DBG_proc, "%s: orig voltage=%.2f, new voltage=%.2f, *applied_multi=%f, new_gain=%d\n",
__func__, original_voltage, voltage, *applied_multi, new_gain);
return new_gain;
}
// todo: is return status necessary (unchecked?)
static void genesys_average_white(Genesys_Device* dev, Genesys_Sensor& sensor, int channels,
int channel, uint8_t* data, int size, int *max_average)
{
DBG_HELPER_ARGS(dbg, "channels=%d, channel=%d, size=%d", channels, channel, size);
int gain_white_ref, sum, range;
int average;
int i;
range = size / 50;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
gain_white_ref = sensor.fau_gain_white_ref * 256;
} else {
gain_white_ref = sensor.gain_white_ref * 256;
}
if (range < 1)
range = 1;
size = size / (2 * range * channels);
data += (channel * 2);
*max_average = 0;
while (size--)
{
sum = 0;
for (i = 0; i < range; i++)
{
sum += (*data);
sum += *(data + 1) * 256;
data += (2 * channels); /* byte based */
}
average = (sum / range);
if (average > *max_average)
*max_average = average;
}
DBG(DBG_proc, "%s: max_average=%d, gain_white_ref = %d, finished\n", __func__, *max_average,
gain_white_ref);
if (*max_average >= gain_white_ref)
throw SaneException(SANE_STATUS_INVAL);
}
/* todo: understand, values are too high */
static int
genesys_average_black (Genesys_Device * dev, int channel,
uint8_t * data, int pixels)
{
int i;
int sum;
int pixel_step;
DBG(DBG_proc, "%s: channel=%d, pixels=%d\n", __func__, channel, pixels);
sum = 0;
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
{
data += (channel * 2);
pixel_step = 3 * 2;
}
else
{
pixel_step = 2;
}
for (i = 0; i < pixels; i++)
{
sum += *data;
sum += *(data + 1) * 256;
data += pixel_step;
}
DBG(DBG_proc, "%s = %d\n", __func__, sum / pixels);
return sum / pixels;
}
// todo: check; it works but the lines 1, 2, and 3 are too dark even with the
// same offset and gain settings?
static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sensor,
Genesys_Register_Set& local_reg)
{
DBG_HELPER_ARGS(dbg, "scan_mode = %d", static_cast<unsigned>(dev->settings.scan_mode));
dev->cmd_set->init_regs_for_coarse_calibration(dev, sensor, local_reg);
if (dev->model->asic_type != AsicType::GL646) {
dev->interface->write_registers(local_reg);
}
int black_pixels;
int white_average;
uint8_t offset[4] = { 0xa0, 0x00, 0xa0, 0x40 }; /* first value isn't used */
uint16_t white[12], dark[12];
int i, j;
black_pixels = sensor.black_pixels
* dev->settings.xres / sensor.optical_res;
unsigned channels = dev->settings.get_channels();
DBG(DBG_info, "channels %d y_size %f xres %d\n", channels, dev->model->y_size,
dev->settings.xres);
unsigned size = static_cast<unsigned>(channels * 2 * dev->model->y_size * dev->settings.xres /
MM_PER_INCH);
/* 1 1 mm 1/inch inch/mm */
std::vector<uint8_t> calibration_data(size);
std::vector<uint8_t> all_data(size * 4, 1);
dev->cmd_set->set_fe(dev, sensor, AFE_INIT);
dev->frontend.set_gain(0, 2);
dev->frontend.set_gain(1, 2);
dev->frontend.set_gain(2, 2); // TODO: ? was 2
dev->frontend.set_offset(0, offset[0]);
dev->frontend.set_offset(1, offset[0]);
dev->frontend.set_offset(2, offset[0]);
for (i = 0; i < 4; i++) /* read 4 lines */
{
if (i < 3) /* first 3 lines */
{
dev->frontend.set_offset(0, offset[i]);
dev->frontend.set_offset(1, offset[i]);
dev->frontend.set_offset(2, offset[i]);
}
if (i == 1) /* second line */
{
double applied_multi;
double gain_white_ref;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED)
{
gain_white_ref = sensor.fau_gain_white_ref * 256;
} else {
gain_white_ref = sensor.gain_white_ref * 256;
}
// white and black are defined downwards
uint8_t gain0 = genesys_adjust_gain(&applied_multi,
gain_white_ref / (white[0] - dark[0]),
dev->frontend.get_gain(0));
uint8_t gain1 = genesys_adjust_gain(&applied_multi,
gain_white_ref / (white[1] - dark[1]),
dev->frontend.get_gain(1));
uint8_t gain2 = genesys_adjust_gain(&applied_multi,
gain_white_ref / (white[2] - dark[2]),
dev->frontend.get_gain(2));
// FIXME: looks like overwritten data. Are the above calculations doing
// anything at all?
dev->frontend.set_gain(0, gain0);
dev->frontend.set_gain(1, gain1);
dev->frontend.set_gain(2, gain2);
dev->frontend.set_gain(0, 2);
dev->frontend.set_gain(1, 2);
dev->frontend.set_gain(2, 2);
dev->interface->write_fe_register(0x28, dev->frontend.get_gain(0));
dev->interface->write_fe_register(0x29, dev->frontend.get_gain(1));
dev->interface->write_fe_register(0x2a, dev->frontend.get_gain(2));
}
if (i == 3) /* last line */
{
double x, y, rate;
for (j = 0; j < 3; j++)
{
x = static_cast<double>(dark[(i - 2) * 3 + j] -
dark[(i - 1) * 3 + j]) * 254 / (offset[i - 1] / 2 -
offset[i - 2] / 2);
y = x - x * (offset[i - 1] / 2) / 254 - dark[(i - 1) * 3 + j];
rate = (x - DARK_VALUE - y) * 254 / x + 0.5;
uint8_t curr_offset = static_cast<uint8_t>(rate);
if (curr_offset > 0x7f) {
curr_offset = 0x7f;
}
curr_offset <<= 1;
dev->frontend.set_offset(j, curr_offset);
}
}
dev->interface->write_fe_register(0x20, dev->frontend.get_offset(0));
dev->interface->write_fe_register(0x21, dev->frontend.get_offset(1));
dev->interface->write_fe_register(0x22, dev->frontend.get_offset(2));
DBG(DBG_info,
"%s: doing scan: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
dev->frontend.get_gain(0),
dev->frontend.get_gain(1),
dev->frontend.get_gain(2),
dev->frontend.get_offset(0),
dev->frontend.get_offset(1),
dev->frontend.get_offset(2));
dev->cmd_set->begin_scan(dev, sensor, &local_reg, false);
if (is_testing_mode()) {
dev->interface->test_checkpoint("coarse_calibration");
dev->cmd_set->end_scan(dev, &local_reg, true);
return;
}
sanei_genesys_read_data_from_scanner(dev, calibration_data.data(), size);
std::memcpy(all_data.data() + i * size, calibration_data.data(), size);
if (i == 3) /* last line */
{
std::vector<uint8_t> all_data_8(size * 4 / 2);
unsigned int count;
for (count = 0; count < static_cast<unsigned>(size * 4 / 2); count++) {
all_data_8[count] = all_data[count * 2 + 1];
}
sanei_genesys_write_pnm_file("gl_coarse.pnm", all_data_8.data(), 8, channels, size / 6, 4);
}
dev->cmd_set->end_scan(dev, &local_reg, true);
if (dev->settings.scan_mode == ScanColorMode::COLOR_SINGLE_PASS)
{
for (j = 0; j < 3; j++)
{
genesys_average_white(dev, sensor, 3, j, calibration_data.data(), size, &white_average);
white[i * 3 + j] = white_average;
dark[i * 3 + j] =
genesys_average_black (dev, j, calibration_data.data(),
black_pixels);
DBG(DBG_info, "%s: white[%d]=%d, black[%d]=%d\n", __func__,
i * 3 + j, white[i * 3 + j], i * 3 + j, dark[i * 3 + j]);
}
}
else /* one color-component modes */
{
genesys_average_white(dev, sensor, 1, 0, calibration_data.data(), size, &white_average);
white[i * 3 + 0] = white[i * 3 + 1] = white[i * 3 + 2] =
white_average;
dark[i * 3 + 0] = dark[i * 3 + 1] = dark[i * 3 + 2] =
genesys_average_black (dev, 0, calibration_data.data(), black_pixels);
}
} /* for (i = 0; i < 4; i++) */
DBG(DBG_info, "%s: final: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
dev->frontend.get_gain(0),
dev->frontend.get_gain(1),
dev->frontend.get_gain(2),
dev->frontend.get_offset(0),
dev->frontend.get_offset(1),
dev->frontend.get_offset(2));
}
/**
* scans a white area with motor and lamp off to get the per CCD pixel offset
* that will be used to compute shading coefficient

37
backend/genesys/gl124.cpp
Wyświetl plik

@ -1134,43 +1134,6 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl124::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::FEEDING |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
sanei_genesys_set_motor_power(regs, false);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration shading calibration is done at dpihw
void CommandSetGl124::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl124.h
Wyświetl plik

@ -125,9 +125,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

14
backend/genesys/gl646.cpp
Wyświetl plik

@ -1643,20 +1643,6 @@ void CommandSetGl646::search_start_position(Genesys_Device* dev) const
}
}
/**
* internally overriden during effective calibration
* sets up register for coarse gain calibration
*/
void CommandSetGl646::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
(void) dev;
(void) sensor;
(void) regs;
}
/**
* init registers for shading calibration

3
backend/genesys/gl646.h
Wyświetl plik

@ -449,9 +449,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

34
backend/genesys/gl841.cpp
Wyświetl plik

@ -2296,40 +2296,6 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl841::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration
void CommandSetGl841::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl841.h
Wyświetl plik

@ -63,9 +63,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

42
backend/genesys/gl843.cpp
Wyświetl plik

@ -1555,48 +1555,6 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl843::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanFlag flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
if (dev->settings.scan_method == ScanMethod::TRANSPARENCY ||
dev->settings.scan_method == ScanMethod::TRANSPARENCY_INFRARED) {
flags |= ScanFlag::USE_XPA;
}
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = flags;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
sanei_genesys_set_motor_power(regs, false);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
static bool should_calibrate_only_active_area(const Genesys_Device& dev,
const Genesys_Settings& settings)
{

3
backend/genesys/gl843.h
Wyświetl plik

@ -63,9 +63,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

33
backend/genesys/gl846.cpp
Wyświetl plik

@ -909,39 +909,6 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl846::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration
void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl846.h
Wyświetl plik

@ -138,9 +138,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;

33
backend/genesys/gl847.cpp
Wyświetl plik

@ -915,39 +915,6 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
}
}
// sets up register for coarse gain calibration
// todo: check it for scanners using it
void CommandSetGl847::init_regs_for_coarse_calibration(Genesys_Device* dev,
const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const
{
DBG_HELPER(dbg);
ScanSession session;
session.params.xres = dev->settings.xres;
session.params.yres = dev->settings.yres;
session.params.startx = 0;
session.params.starty = 0;
session.params.pixels = sensor.optical_res / sensor.ccd_pixels_per_system_pixel();
session.params.lines = 20;
session.params.depth = 16;
session.params.channels = dev->settings.get_channels();
session.params.scan_method = dev->settings.scan_method;
session.params.scan_mode = dev->settings.scan_mode;
session.params.color_filter = dev->settings.color_filter;
session.params.flags = ScanFlag::DISABLE_SHADING |
ScanFlag::DISABLE_GAMMA |
ScanFlag::SINGLE_LINE |
ScanFlag::IGNORE_STAGGER_OFFSET |
ScanFlag::IGNORE_COLOR_OFFSET;
compute_session(dev, session, sensor);
init_regs_for_scan_session(dev, sensor, &regs, session);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
}
// init registers for shading calibration
void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const

3
backend/genesys/gl847.h
Wyświetl plik

@ -126,9 +126,6 @@ public:
Genesys_Register_Set* regs, int* channels,
int* total_size) const override;
void init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;
void init_regs_for_shading(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set& regs) const override;