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

Merge branch 'genesys-fix-search-reference-point' into 'master' 

genesys: Fix search reference point to update all sensors

See merge request sane-project/backends!118
merge-requests/123/head
Povilas Kanapickas 2019-08-10 11:55:49 +00:00
rodzic 6bf49297c2 e5a90e8005
commit 7d6897ecb4
9 zmienionych plików z 143 dodań i 53 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

81
backend/genesys.cc
Wyświetl plik

@ -230,6 +230,28 @@ Genesys_Sensor& sanei_genesys_find_sensor_for_write(Genesys_Device* dev, int dpi
}
std::vector<std::reference_wrapper<const Genesys_Sensor>>
sanei_genesys_find_sensors_all(Genesys_Device* dev, ScanMethod scan_method)
{
std::vector<std::reference_wrapper<const Genesys_Sensor>> ret;
for (const Genesys_Sensor& sensor : sanei_genesys_find_sensors_all_for_write(dev, scan_method)) {
ret.push_back(sensor);
}
return ret;
}
std::vector<std::reference_wrapper<Genesys_Sensor>>
sanei_genesys_find_sensors_all_for_write(Genesys_Device* dev, ScanMethod scan_method)
{
std::vector<std::reference_wrapper<Genesys_Sensor>> ret;
for (auto& sensor : *s_sensors) {
if (dev->model->ccd_type == sensor.sensor_id && sensor.method == scan_method) {
ret.push_back(sensor);
}
}
return ret;
}
void
sanei_genesys_init_structs (Genesys_Device * dev)
{
@ -1053,8 +1075,8 @@ void sanei_genesys_init_shading_data(Genesys_Device* dev, const Genesys_Sensor&
// Find the position of the reference point: takes gray level 8 bits data and find
// first CCD usable pixel and top of scanning area
void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& sensor,
uint8_t* data, int start_pixel, int dpi, int width,
int height)
const uint8_t* src_data, int start_pixel, int dpi,
int width, int height)
{
DBG_HELPER(dbg);
int x, y;
@ -1069,22 +1091,25 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
/* transformed image data */
size = width * height;
std::vector<uint8_t> image2(size, 0);
std::vector<uint8_t> image(size, 0);
/* laplace filter to denoise picture */
memcpy(image.data(), data, size); // to initialize unprocessed part of the image buffer
for (y = 1; y < height - 1; y++)
for (x = 1; x < width - 1; x++)
{
image[y * width + x] =
(data[(y - 1) * width + x + 1] + 2 * data[(y - 1) * width + x] +
data[(y - 1) * width + x - 1] + 2 * data[y * width + x + 1] +
4 * data[y * width + x] + 2 * data[y * width + x - 1] +
data[(y + 1) * width + x + 1] + 2 * data[(y + 1) * width + x] +
data[(y + 1) * width + x - 1]) / 16;
}
std::memcpy(image2.data(), src_data, size);
std::memcpy(image.data(), src_data, size); // to initialize unprocessed part of the image buffer
memcpy (data, image.data(), size);
for (y = 1; y < height - 1; y++) {
for (x = 1; x < width - 1; x++) {
image[y * width + x] =
(image2[(y - 1) * width + x + 1] + 2 * image2[(y - 1) * width + x] +
image2[(y - 1) * width + x - 1] + 2 * image2[y * width + x + 1] +
4 * image2[y * width + x] + 2 * image2[y * width + x - 1] +
image2[(y + 1) * width + x + 1] + 2 * image2[(y + 1) * width + x] +
image2[(y + 1) * width + x - 1]) / 16;
}
}
image2 = image;
if (DBG_LEVEL >= DBG_data)
sanei_genesys_write_pnm_file("gl_laplace.pnm", image.data(), 8, 1, width, height);
@ -1095,13 +1120,11 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
and finds threshold level
*/
level = 0;
for (y = 2; y < height - 2; y++)
for (x = 2; x < width - 2; x++)
{
current =
data[(y - 1) * width + x + 1] - data[(y - 1) * width + x - 1] +
2 * data[y * width + x + 1] - 2 * data[y * width + x - 1] +
data[(y + 1) * width + x + 1] - data[(y + 1) * width + x - 1];
for (y = 2; y < height - 2; y++) {
for (x = 2; x < width - 2; x++) {
current = image2[(y - 1) * width + x + 1] - image2[(y - 1) * width + x - 1] +
2 * image2[y * width + x + 1] - 2 * image2[y * width + x - 1] +
image2[(y + 1) * width + x + 1] - image2[(y + 1) * width + x - 1];
if (current < 0)
current = -current;
if (current > 255)
@ -1109,7 +1132,8 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
image[y * width + x] = current;
if (current > level)
level = current;
}
}
}
if (DBG_LEVEL >= DBG_data)
sanei_genesys_write_pnm_file("gl_xsobel.pnm", image.data(), 8, 1, width, height);
@ -1146,13 +1170,11 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
1 2 1
*/
level = 0;
for (y = 2; y < height - 2; y++)
for (x = 2; x < width - 2; x++)
{
current =
-data[(y - 1) * width + x + 1] - 2 * data[(y - 1) * width + x] -
data[(y - 1) * width + x - 1] + data[(y + 1) * width + x + 1] +
2 * data[(y + 1) * width + x] + data[(y + 1) * width + x - 1];
for (y = 2; y < height - 2; y++) {
for (x = 2; x < width - 2; x++) {
current = -image2[(y - 1) * width + x + 1] - 2 * image2[(y - 1) * width + x] -
image2[(y - 1) * width + x - 1] + image2[(y + 1) * width + x + 1] +
2 * image2[(y + 1) * width + x] + image2[(y + 1) * width + x - 1];
if (current < 0)
current = -current;
if (current > 255)
@ -1161,6 +1183,7 @@ void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& s
if (current > level)
level = current;
}
}
if (DBG_LEVEL >= DBG_data)
sanei_genesys_write_pnm_file("gl_ysobel.pnm", image.data(), 8, 1, width, height);

6
backend/genesys_gl124.cc
Wyświetl plik

@ -1939,8 +1939,10 @@ static void gl124_search_start_position(Genesys_Device* dev)
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
dev->model->search_lines);
for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
dev->model->search_lines);
}
}
// sets up register for coarse gain calibration

16
backend/genesys_gl646.cc
Wyświetl plik

@ -375,6 +375,9 @@ static void gl646_setup_registers(Genesys_Device* dev,
DBG_HELPER(dbg);
session.assert_computed();
debug_dump(DBG_info, sensor);
debug_dump(DBG_info, session);
int resolution = session.params.xres;
uint32_t move = session.params.starty;
uint32_t linecnt = session.params.lines;
@ -2180,8 +2183,10 @@ static void gl646_search_start_position(Genesys_Device* dev)
}
// now search reference points on the data
sanei_genesys_search_reference_point(dev, sensor, data.data(), sensor.CCD_start_xoffset,
resolution, settings.pixels, settings.lines);
for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0,
resolution, settings.pixels, settings.lines);
}
}
/**
@ -2888,13 +2893,6 @@ static void gl646_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
}
}
// in case of debug do a final scan to get result
if (DBG_LEVEL >= DBG_data) {
simple_scan(dev, sensor, settings, SANE_FALSE, SANE_TRUE, SANE_FALSE, second_line);
sanei_genesys_write_pnm_file("gl646_offset-final.pnm", second_line.data(), 8, channels,
settings.pixels, settings.lines);
}
DBG(DBG_info, "%s: offset=(%d,%d,%d)\n", __func__,
dev->frontend.get_offset(0),
dev->frontend.get_offset(1),

8
backend/genesys_gl841.cc
Wyświetl plik

@ -2991,10 +2991,10 @@ static void gl841_search_start_position(Genesys_Device* dev)
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
// TODO: find out where sanei_genesys_search_reference_point stores information,
// and use that correctly
sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
dev->model->search_lines);
for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
dev->model->search_lines);
}
}
// sets up register for coarse gain calibration

6
backend/genesys_gl843.cc
Wyświetl plik

@ -2351,8 +2351,10 @@ static void gl843_search_start_position(Genesys_Device* dev)
/* update regs to copy ASIC internal state */
dev->reg = local_reg;
sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
dev->model->search_lines);
for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
dev->model->search_lines);
}
}
// sets up register for coarse gain calibration

6
backend/genesys_gl846.cc
Wyświetl plik

@ -1632,8 +1632,10 @@ static void gl846_search_start_position(Genesys_Device* dev)
// TODO: find out where sanei_genesys_search_reference_point stores information,
// and use that correctly
sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
dev->model->search_lines);
for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
dev->model->search_lines);
}
}
// sets up register for coarse gain calibration

6
backend/genesys_gl847.cc
Wyświetl plik

@ -1688,8 +1688,10 @@ static void gl847_search_start_position(Genesys_Device* dev)
// TODO: find out where sanei_genesys_search_reference_point stores information,
// and use that correctly
sanei_genesys_search_reference_point(dev, sensor, data.data(), 0, dpi, pixels,
dev->model->search_lines);
for (auto& sensor_update : sanei_genesys_find_sensors_all_for_write(dev, ScanMethod::FLATBED)) {
sanei_genesys_search_reference_point(dev, sensor_update, data.data(), 0, dpi, pixels,
dev->model->search_lines);
}
}
// sets up register for coarse gain calibration

55
backend/genesys_low.cc
Wyświetl plik

@ -1705,13 +1705,30 @@ void debug_dump(unsigned level, const SetupParams& params)
params.flags);
}
void debug_dump(unsigned level, const ScanSession& session)
{
DBG(level, "session:\n");
DBG(level, " computed : %d\n", session.computed);
DBG(level, " ccd_size_divisor : %d\n", session.ccd_size_divisor);
DBG(level, " optical_resolution : %d\n", session.optical_resolution);
DBG(level, " optical_pixels : %d\n", session.optical_pixels);
DBG(level, " optical_line_bytes : %d\n", session.optical_line_bytes);
DBG(level, " output_resolution : %d\n", session.output_resolution);
DBG(level, " output_pixels : %d\n", session.output_pixels);
DBG(level, " output_line_bytes : %d\n", session.output_line_bytes);
DBG(level, " output_line_count : %d\n", session.output_line_count);
DBG(level, " num_staggered_lines : %d\n", session.num_staggered_lines);
DBG(level, " max_color_shift_lines : %d\n", session.max_color_shift_lines);
debug_dump(level, session.params);
}
void debug_dump(unsigned level, const Genesys_Current_Setup& setup)
{
DBG(level, "current_setup:\n"
"Pixels: %d\n"
"Lines: %d\n"
"exposure_time: %d\n"
"Resolution X/Y: %g\n"
"Resolution X: %g\n"
"ccd_size_divisor: %d\n"
"stagger: %d\n"
"max_shift: %d\n",
@ -1731,3 +1748,39 @@ void debug_dump(unsigned level, const Genesys_Register_Set& regs)
DBG(level, " %04x=%02x\n", reg.address, reg.value);
}
}
void debug_dump(unsigned level, const GenesysRegisterSettingSet& regs)
{
DBG(level, "register_setting_set:\n");
for (const auto& reg : regs) {
DBG(level, " %04x=%02x & %02x\n", reg.address, reg.value, reg.mask);
}
}
void debug_dump(unsigned level, const Genesys_Sensor& sensor)
{
DBG(level, "sensor:\n");
DBG(level, " sensor_id : %d\n", sensor.sensor_id);
DBG(level, " optical_res : %d\n", sensor.optical_res);
DBG(level, " min_resolution : %d\n", sensor.min_resolution);
DBG(level, " max_resolution : %d\n", sensor.max_resolution);
DBG(level, " method : %d\n", static_cast<unsigned>(sensor.method));
DBG(level, " ccd_size_divisor : %d\n", sensor.ccd_size_divisor);
DBG(level, " black_pixels : %d\n", sensor.black_pixels);
DBG(level, " dummy_pixel : %d\n", sensor.dummy_pixel);
DBG(level, " CCD_start_xoffset : %d\n", sensor.CCD_start_xoffset);
DBG(level, " sensor_pixels : %d\n", sensor.sensor_pixels);
DBG(level, " fau_gain_white_ref : %d\n", sensor.fau_gain_white_ref);
DBG(level, " gain_white_ref : %d\n", sensor.gain_white_ref);
DBG(level, " exposure.red : %d\n", sensor.exposure.red);
DBG(level, " exposure.green : %d\n", sensor.exposure.green);
DBG(level, " exposure.blue : %d\n", sensor.exposure.blue);
DBG(level, " exposure_lperiod : %d\n", sensor.exposure_lperiod);
DBG(level, " custom_regs\n");
debug_dump(level, sensor.custom_regs);
DBG(level, " custom_fe_regs\n");
debug_dump(level, sensor.custom_fe_regs);
DBG(level, " gamma.red : %f\n", sensor.gamma[0]);
DBG(level, " gamma.green : %f\n", sensor.gamma[1]);
DBG(level, " gamma.blue : %f\n", sensor.gamma[2]);
}

12
backend/genesys_low.h
Wyświetl plik

@ -439,6 +439,11 @@ const Genesys_Sensor& sanei_genesys_find_sensor(Genesys_Device* dev, int dpi,
Genesys_Sensor& sanei_genesys_find_sensor_for_write(Genesys_Device* dev, int dpi,
ScanMethod scan_method);
std::vector<std::reference_wrapper<const Genesys_Sensor>>
sanei_genesys_find_sensors_all(Genesys_Device* dev, ScanMethod scan_method);
std::vector<std::reference_wrapper<Genesys_Sensor>>
sanei_genesys_find_sensors_all_for_write(Genesys_Device* dev, ScanMethod scan_method);
extern void sanei_genesys_init_shading_data(Genesys_Device* dev, const Genesys_Sensor& sensor,
int pixels_per_line);
@ -525,8 +530,8 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
extern void sanei_genesys_stop_motor(Genesys_Device* dev);
extern void sanei_genesys_search_reference_point(Genesys_Device* dev, Genesys_Sensor& sensor,
uint8_t* data, int start_pixel, int dpi, int width,
int height);
const uint8_t* src_data, int start_pixel, int dpi,
int width, int height);
extern void sanei_genesys_write_file(const char* filename, uint8_t* data, size_t length);
@ -683,7 +688,10 @@ void genesys_init_usb_device_tables();
void debug_dump(unsigned level, const Genesys_Settings& settings);
void debug_dump(unsigned level, const SetupParams& params);
void debug_dump(unsigned level, const ScanSession& session);
void debug_dump(unsigned level, const Genesys_Current_Setup& setup);
void debug_dump(unsigned level, const Genesys_Register_Set& regs);
void debug_dump(unsigned level, const GenesysRegisterSettingSet& regs);
void debug_dump(unsigned level, const Genesys_Sensor& sensor);
#endif /* not GENESYS_LOW_H */