You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
633 lines
22 KiB
633 lines
22 KiB
/*
|
|
* Copyright (C) 2012 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "EmulatedScene"
|
|
#include "EmulatedScene.h"
|
|
#include "EmulatedSensor.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <utils/Log.h>
|
|
|
|
#include <cmath>
|
|
|
|
// TODO: This should probably be done host-side in OpenGL for speed and better
|
|
// quality
|
|
|
|
namespace android {
|
|
|
|
using ::android::frameworks::sensorservice::V1_0::ISensorManager;
|
|
using ::android::frameworks::sensorservice::V1_0::Result;
|
|
using ::android::hardware::sensors::V1_0::SensorInfo;
|
|
using ::android::hardware::sensors::V1_0::SensorType;
|
|
|
|
// Define single-letter shortcuts for scene definition, for directly indexing
|
|
// mCurrentColors
|
|
#define G (EmulatedScene::GRASS * EmulatedScene::NUM_CHANNELS)
|
|
#define S (EmulatedScene::GRASS_SHADOW * EmulatedScene::NUM_CHANNELS)
|
|
#define H (EmulatedScene::HILL * EmulatedScene::NUM_CHANNELS)
|
|
#define W (EmulatedScene::WALL * EmulatedScene::NUM_CHANNELS)
|
|
#define R (EmulatedScene::ROOF * EmulatedScene::NUM_CHANNELS)
|
|
#define D (EmulatedScene::DOOR * EmulatedScene::NUM_CHANNELS)
|
|
#define C (EmulatedScene::CHIMNEY * EmulatedScene::NUM_CHANNELS)
|
|
#define I (EmulatedScene::WINDOW * EmulatedScene::NUM_CHANNELS)
|
|
#define U (EmulatedScene::SUN * EmulatedScene::NUM_CHANNELS)
|
|
#define K (EmulatedScene::SKY * EmulatedScene::NUM_CHANNELS)
|
|
#define M (EmulatedScene::MOON * EmulatedScene::NUM_CHANNELS)
|
|
|
|
const uint8_t EmulatedScene::kScene[EmulatedScene::kSceneWidth *
|
|
EmulatedScene::kSceneHeight] = {
|
|
// 5 10 15 20
|
|
K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K,
|
|
K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K,
|
|
K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K,
|
|
K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K,
|
|
K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, // 5
|
|
K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K,
|
|
K, K, K, K, K, K, K, K, H, H, H, H, H, H, H, H, H, H, H, H,
|
|
K, K, K, K, K, K, K, K, H, H, H, H, H, H, H, C, C, H, H, H,
|
|
K, K, K, K, K, K, H, H, H, H, H, H, H, H, H, C, C, H, H, H,
|
|
H, K, K, K, K, K, H, R, R, R, R, R, R, R, R, R, R, R, R, H, // 10
|
|
H, K, K, K, K, H, H, R, R, R, R, R, R, R, R, R, R, R, R, H,
|
|
H, H, H, K, K, H, H, R, R, R, R, R, R, R, R, R, R, R, R, H,
|
|
H, H, H, K, K, H, H, H, W, W, W, W, W, W, W, W, W, W, H, H,
|
|
S, S, S, G, G, S, S, S, W, W, W, W, W, W, W, W, W, W, S, S,
|
|
S, G, G, G, G, S, S, S, W, I, I, W, D, D, W, I, I, W, S, S, // 15
|
|
G, G, G, G, G, G, S, S, W, I, I, W, D, D, W, I, I, W, S, S,
|
|
G, G, G, G, G, G, G, G, W, W, W, W, D, D, W, W, W, W, G, G,
|
|
G, G, G, G, G, G, G, G, W, W, W, W, D, D, W, W, W, W, G, G,
|
|
G, G, G, G, G, G, G, G, S, S, S, S, S, S, S, S, S, S, G, G,
|
|
G, G, G, G, G, G, G, G, S, S, S, S, S, S, S, S, S, S, G, G, // 20
|
|
// 5 10 15 20
|
|
};
|
|
|
|
#undef G
|
|
#undef S
|
|
#undef H
|
|
#undef W
|
|
#undef R
|
|
#undef D
|
|
#undef C
|
|
#undef I
|
|
#undef U
|
|
#undef K
|
|
#undef M
|
|
|
|
EmulatedScene::EmulatedScene(int sensor_width_px, int sensor_height_px,
|
|
float sensor_sensitivity, int sensor_orientation,
|
|
bool is_front_facing)
|
|
: sensor_handle_(-1),
|
|
screen_rotation_(0),
|
|
current_scene_(scene_rot0_),
|
|
sensor_orientation_(sensor_orientation),
|
|
is_front_facing_(is_front_facing),
|
|
hour_(12),
|
|
exposure_duration_(0.033f) {
|
|
// Assume that sensor filters are sRGB primaries to start
|
|
filter_r_[0] = 3.2406f;
|
|
filter_r_[1] = -1.5372f;
|
|
filter_r_[2] = -0.4986f;
|
|
filter_gr_[0] = -0.9689f;
|
|
filter_gr_[1] = 1.8758f;
|
|
filter_gr_[2] = 0.0415f;
|
|
filter_gb_[0] = -0.9689f;
|
|
filter_gb_[1] = 1.8758f;
|
|
filter_gb_[2] = 0.0415f;
|
|
filter_b_[0] = 0.0557f;
|
|
filter_b_[1] = -0.2040f;
|
|
filter_b_[2] = 1.0570f;
|
|
|
|
InitiliazeSceneRotation(!is_front_facing_);
|
|
Initialize(sensor_width_px, sensor_height_px, sensor_sensitivity);
|
|
}
|
|
|
|
EmulatedScene::~EmulatedScene() {
|
|
if (sensor_event_queue_.get() != nullptr) {
|
|
sensor_event_queue_->disableSensor(sensor_handle_);
|
|
sensor_event_queue_.clear();
|
|
sensor_event_queue_ = nullptr;
|
|
}
|
|
}
|
|
|
|
void EmulatedScene::Initialize(int sensor_width_px, int sensor_height_px,
|
|
float sensor_sensitivity) {
|
|
sensor_width_ = sensor_width_px;
|
|
sensor_height_ = sensor_height_px;
|
|
sensor_sensitivity_ = sensor_sensitivity;
|
|
|
|
// Map scene to sensor pixels
|
|
if (sensor_width_ > sensor_height_) {
|
|
map_div_ = (sensor_width_ / (kSceneWidth + 1)) + 1;
|
|
}
|
|
else {
|
|
map_div_ = (sensor_height_ / (kSceneHeight + 1)) + 1;
|
|
}
|
|
offset_x_ = (kSceneWidth * map_div_ - sensor_width_) / 2;
|
|
offset_y_ = (kSceneHeight * map_div_ - sensor_height_) / 2;
|
|
|
|
}
|
|
|
|
Return<void> EmulatedScene::SensorHandler::onEvent(const Event& e) {
|
|
auto scene = scene_.promote();
|
|
if (scene.get() == nullptr) {
|
|
return Void();
|
|
}
|
|
|
|
if (e.sensorType == SensorType::ACCELEROMETER) {
|
|
// Heuristic approach for deducing the screen
|
|
// rotation depending on the reported
|
|
// accelerometer readings. We switch
|
|
// the screen rotation when one of the
|
|
// x/y axis gets close enough to the earth
|
|
// acceleration.
|
|
const uint32_t earth_accel = 9; // Switch threshold [m/s^2]
|
|
uint32_t x_accel = e.u.vec3.x;
|
|
uint32_t y_accel = e.u.vec3.y;
|
|
if (x_accel == earth_accel) {
|
|
scene->screen_rotation_ = 270;
|
|
} else if (x_accel == -earth_accel) {
|
|
scene->screen_rotation_ = 90;
|
|
} else if (y_accel == -earth_accel) {
|
|
scene->screen_rotation_ = 180;
|
|
} else {
|
|
scene->screen_rotation_ = 0;
|
|
}
|
|
} else {
|
|
ALOGE("%s: unexpected event received type: %d", __func__, e.sensorType);
|
|
}
|
|
return Void();
|
|
}
|
|
|
|
void EmulatedScene::SetColorFilterXYZ(float rX, float rY, float rZ, float grX,
|
|
float grY, float grZ, float gbX, float gbY,
|
|
float gbZ, float bX, float bY, float bZ) {
|
|
filter_r_[0] = rX;
|
|
filter_r_[1] = rY;
|
|
filter_r_[2] = rZ;
|
|
filter_gr_[0] = grX;
|
|
filter_gr_[1] = grY;
|
|
filter_gr_[2] = grZ;
|
|
filter_gb_[0] = gbX;
|
|
filter_gb_[1] = gbY;
|
|
filter_gb_[2] = gbZ;
|
|
filter_b_[0] = bX;
|
|
filter_b_[1] = bY;
|
|
filter_b_[2] = bZ;
|
|
}
|
|
|
|
void EmulatedScene::SetHour(int hour) {
|
|
ALOGV("Hour set to: %d", hour);
|
|
hour_ = hour % 24;
|
|
}
|
|
|
|
int EmulatedScene::GetHour() const {
|
|
return hour_;
|
|
}
|
|
|
|
void EmulatedScene::SetExposureDuration(float seconds) {
|
|
exposure_duration_ = seconds;
|
|
}
|
|
|
|
void EmulatedScene::SetTestPattern(bool enabled) {
|
|
test_pattern_mode_ = enabled;
|
|
}
|
|
|
|
void EmulatedScene::SetTestPatternData(uint32_t data[4]) {
|
|
memcpy(test_pattern_data_, data, 4);
|
|
}
|
|
|
|
void EmulatedScene::CalculateScene(nsecs_t time, int32_t handshake_divider) {
|
|
// Calculate time fractions for interpolation
|
|
int time_idx = hour_ / kTimeStep;
|
|
int next_time_idx = (time_idx + 1) % (24 / kTimeStep);
|
|
const nsecs_t kOneHourInNsec = 1e9 * 60 * 60;
|
|
nsecs_t time_since_idx =
|
|
(hour_ - time_idx * kTimeStep) * kOneHourInNsec + time;
|
|
float time_frac = time_since_idx / (float)(kOneHourInNsec * kTimeStep);
|
|
|
|
// Determine overall sunlight levels
|
|
float sun_lux = kSunlight[time_idx] * (1 - time_frac) +
|
|
kSunlight[next_time_idx] * time_frac;
|
|
ALOGV("Sun lux: %f", sun_lux);
|
|
|
|
float sun_shade_lux = sun_lux * (kDaylightShadeIllum / kDirectSunIllum);
|
|
|
|
// Determine sun/shade illumination chromaticity
|
|
float current_sun_xy[2];
|
|
float current_shade_xy[2];
|
|
|
|
const float *prev_sun_xy, *next_sun_xy;
|
|
const float *prev_shade_xy, *next_shade_xy;
|
|
if (kSunlight[time_idx] == kSunsetIllum ||
|
|
kSunlight[time_idx] == kTwilightIllum) {
|
|
prev_sun_xy = kSunsetXY;
|
|
prev_shade_xy = kSunsetXY;
|
|
} else {
|
|
prev_sun_xy = kDirectSunlightXY;
|
|
prev_shade_xy = kDaylightXY;
|
|
}
|
|
if (kSunlight[next_time_idx] == kSunsetIllum ||
|
|
kSunlight[next_time_idx] == kTwilightIllum) {
|
|
next_sun_xy = kSunsetXY;
|
|
next_shade_xy = kSunsetXY;
|
|
} else {
|
|
next_sun_xy = kDirectSunlightXY;
|
|
next_shade_xy = kDaylightXY;
|
|
}
|
|
current_sun_xy[0] =
|
|
prev_sun_xy[0] * (1 - time_frac) + next_sun_xy[0] * time_frac;
|
|
current_sun_xy[1] =
|
|
prev_sun_xy[1] * (1 - time_frac) + next_sun_xy[1] * time_frac;
|
|
|
|
current_shade_xy[0] =
|
|
prev_shade_xy[0] * (1 - time_frac) + next_shade_xy[0] * time_frac;
|
|
current_shade_xy[1] =
|
|
prev_shade_xy[1] * (1 - time_frac) + next_shade_xy[1] * time_frac;
|
|
|
|
ALOGV("Sun XY: %f, %f, Shade XY: %f, %f", current_sun_xy[0],
|
|
current_sun_xy[1], current_shade_xy[0], current_shade_xy[1]);
|
|
|
|
// Converting for xyY to XYZ:
|
|
// X = Y / y * x
|
|
// Y = Y
|
|
// Z = Y / y * (1 - x - y);
|
|
float sun_xyz[3] = {sun_lux / current_sun_xy[1] * current_sun_xy[0], sun_lux,
|
|
sun_lux / current_sun_xy[1] *
|
|
(1 - current_sun_xy[0] - current_sun_xy[1])};
|
|
float sun_shade_xyz[3] = {
|
|
sun_shade_lux / current_shade_xy[1] * current_shade_xy[0], sun_shade_lux,
|
|
sun_shade_lux / current_shade_xy[1] *
|
|
(1 - current_shade_xy[0] - current_shade_xy[1])};
|
|
ALOGV("Sun XYZ: %f, %f, %f", sun_xyz[0], sun_xyz[1], sun_xyz[2]);
|
|
ALOGV("Sun shade XYZ: %f, %f, %f", sun_shade_xyz[0], sun_shade_xyz[1],
|
|
sun_shade_xyz[2]);
|
|
|
|
// Determine moonlight levels
|
|
float moon_lux = kMoonlight[time_idx] * (1 - time_frac) +
|
|
kMoonlight[next_time_idx] * time_frac;
|
|
float moonshade_lux = moon_lux * (kDaylightShadeIllum / kDirectSunIllum);
|
|
|
|
float moon_xyz[3] = {
|
|
moon_lux / kMoonlightXY[1] * kMoonlightXY[0], moon_lux,
|
|
moon_lux / kMoonlightXY[1] * (1 - kMoonlightXY[0] - kMoonlightXY[1])};
|
|
float moon_shade_xyz[3] = {
|
|
moonshade_lux / kMoonlightXY[1] * kMoonlightXY[0], moonshade_lux,
|
|
moonshade_lux / kMoonlightXY[1] * (1 - kMoonlightXY[0] - kMoonlightXY[1])};
|
|
|
|
// Determine starlight level
|
|
const float kClearNightXYZ[3] = {
|
|
kClearNightIllum / kMoonlightXY[1] * kMoonlightXY[0], kClearNightIllum,
|
|
kClearNightIllum / kMoonlightXY[1] *
|
|
(1 - kMoonlightXY[0] - kMoonlightXY[1])};
|
|
|
|
// Calculate direct and shaded light
|
|
float direct_illum_xyz[3] = {
|
|
sun_xyz[0] + moon_xyz[0] + kClearNightXYZ[0],
|
|
sun_xyz[1] + moon_xyz[1] + kClearNightXYZ[1],
|
|
sun_xyz[2] + moon_xyz[2] + kClearNightXYZ[2],
|
|
};
|
|
|
|
float shade_illum_xyz[3] = {kClearNightXYZ[0], kClearNightXYZ[1],
|
|
kClearNightXYZ[2]};
|
|
|
|
shade_illum_xyz[0] += (hour_ < kSunOverhead) ? sun_xyz[0] : sun_shade_xyz[0];
|
|
shade_illum_xyz[1] += (hour_ < kSunOverhead) ? sun_xyz[1] : sun_shade_xyz[1];
|
|
shade_illum_xyz[2] += (hour_ < kSunOverhead) ? sun_xyz[2] : sun_shade_xyz[2];
|
|
|
|
// Moon up period covers 23->0 transition, shift for simplicity
|
|
int adj_hour = (hour_ + 12) % 24;
|
|
int adj_moon_overhead = (kMoonOverhead + 12) % 24;
|
|
shade_illum_xyz[0] +=
|
|
(adj_hour < adj_moon_overhead) ? moon_xyz[0] : moon_shade_xyz[0];
|
|
shade_illum_xyz[1] +=
|
|
(adj_hour < adj_moon_overhead) ? moon_xyz[1] : moon_shade_xyz[1];
|
|
shade_illum_xyz[2] +=
|
|
(adj_hour < adj_moon_overhead) ? moon_xyz[2] : moon_shade_xyz[2];
|
|
|
|
ALOGV("Direct XYZ: %f, %f, %f", direct_illum_xyz[0], direct_illum_xyz[1],
|
|
direct_illum_xyz[2]);
|
|
ALOGV("Shade XYZ: %f, %f, %f", shade_illum_xyz[0], shade_illum_xyz[1],
|
|
shade_illum_xyz[2]);
|
|
|
|
for (int i = 0; i < NUM_MATERIALS; i++) {
|
|
// Converting for xyY to XYZ:
|
|
// X = Y / y * x
|
|
// Y = Y
|
|
// Z = Y / y * (1 - x - y);
|
|
float mat_xyz[3] = {
|
|
kMaterials_xyY[i][2] / kMaterials_xyY[i][1] * kMaterials_xyY[i][0],
|
|
kMaterials_xyY[i][2],
|
|
kMaterials_xyY[i][2] / kMaterials_xyY[i][1] *
|
|
(1 - kMaterials_xyY[i][0] - kMaterials_xyY[i][1])};
|
|
|
|
if (kMaterialsFlags[i] == 0 || kMaterialsFlags[i] & kSky) {
|
|
mat_xyz[0] *= direct_illum_xyz[0];
|
|
mat_xyz[1] *= direct_illum_xyz[1];
|
|
mat_xyz[2] *= direct_illum_xyz[2];
|
|
} else if (kMaterialsFlags[i] & kShadowed) {
|
|
mat_xyz[0] *= shade_illum_xyz[0];
|
|
mat_xyz[1] *= shade_illum_xyz[1];
|
|
mat_xyz[2] *= shade_illum_xyz[2];
|
|
} // else if (kMaterialsFlags[i] * kSelfLit), do nothing
|
|
|
|
ALOGV("Mat %d XYZ: %f, %f, %f", i, mat_xyz[0], mat_xyz[1], mat_xyz[2]);
|
|
float lux_to_electrons =
|
|
sensor_sensitivity_ * exposure_duration_ / (kAperture * kAperture);
|
|
current_colors_[i * NUM_CHANNELS + 0] =
|
|
(filter_r_[0] * mat_xyz[0] + filter_r_[1] * mat_xyz[1] +
|
|
filter_r_[2] * mat_xyz[2]) *
|
|
lux_to_electrons;
|
|
current_colors_[i * NUM_CHANNELS + 1] =
|
|
(filter_gr_[0] * mat_xyz[0] + filter_gr_[1] * mat_xyz[1] +
|
|
filter_gr_[2] * mat_xyz[2]) *
|
|
lux_to_electrons;
|
|
current_colors_[i * NUM_CHANNELS + 2] =
|
|
(filter_gb_[0] * mat_xyz[0] + filter_gb_[1] * mat_xyz[1] +
|
|
filter_gb_[2] * mat_xyz[2]) *
|
|
lux_to_electrons;
|
|
current_colors_[i * NUM_CHANNELS + 3] =
|
|
(filter_b_[0] * mat_xyz[0] + filter_b_[1] * mat_xyz[1] +
|
|
filter_b_[2] * mat_xyz[2]) *
|
|
lux_to_electrons;
|
|
|
|
ALOGV("Color %d RGGB: %d, %d, %d, %d", i,
|
|
current_colors_[i * NUM_CHANNELS + 0],
|
|
current_colors_[i * NUM_CHANNELS + 1],
|
|
current_colors_[i * NUM_CHANNELS + 2],
|
|
current_colors_[i * NUM_CHANNELS + 3]);
|
|
}
|
|
// Shake viewpoint; horizontal and vertical sinusoids at roughly
|
|
// human handshake frequencies
|
|
handshake_x_ =
|
|
(kFreq1Magnitude * std::sin(kHorizShakeFreq1 * time_since_idx) +
|
|
kFreq2Magnitude * std::sin(kHorizShakeFreq2 * time_since_idx)) *
|
|
map_div_ * kShakeFraction;
|
|
if (handshake_divider > 0) {
|
|
handshake_x_ /= handshake_divider;
|
|
}
|
|
|
|
handshake_y_ = (kFreq1Magnitude * std::sin(kVertShakeFreq1 * time_since_idx) +
|
|
kFreq2Magnitude * std::sin(kVertShakeFreq2 * time_since_idx)) *
|
|
map_div_ * kShakeFraction;
|
|
if (handshake_divider > 0) {
|
|
handshake_y_ /= handshake_divider;
|
|
}
|
|
|
|
if (sensor_event_queue_.get() != nullptr) {
|
|
int32_t sensor_orientation = is_front_facing_ ? -sensor_orientation_ : sensor_orientation_;
|
|
int32_t scene_rotation = ((screen_rotation_ + 360) + sensor_orientation) % 360;
|
|
switch (scene_rotation) {
|
|
case 90:
|
|
current_scene_ = scene_rot90_;
|
|
break;
|
|
case 180:
|
|
current_scene_ = scene_rot180_;
|
|
break;
|
|
case 270:
|
|
current_scene_ = scene_rot270_;
|
|
break;
|
|
default:
|
|
current_scene_ = scene_rot0_;
|
|
}
|
|
} else {
|
|
current_scene_ = scene_rot0_;
|
|
}
|
|
|
|
// Set starting pixel
|
|
SetReadoutPixel(0, 0);
|
|
}
|
|
|
|
void EmulatedScene::InitiliazeSceneRotation(bool clock_wise) {
|
|
memcpy(scene_rot0_, kScene, sizeof(scene_rot0_));
|
|
|
|
size_t c = 0;
|
|
for (ssize_t i = kSceneHeight-1; i >= 0; i--) {
|
|
for (ssize_t j = kSceneWidth-1; j >= 0; j--) {
|
|
scene_rot180_[c++] = kScene[i*kSceneWidth + j];
|
|
}
|
|
}
|
|
|
|
c = 0;
|
|
for (ssize_t i = kSceneWidth-1; i >= 0; i--) {
|
|
for (size_t j = 0; j < kSceneHeight; j++) {
|
|
if (clock_wise) {
|
|
scene_rot90_[c++] = kScene[j*kSceneWidth + i];
|
|
} else {
|
|
scene_rot270_[c++] = kScene[j*kSceneWidth + i];
|
|
}
|
|
}
|
|
}
|
|
|
|
c = 0;
|
|
for (size_t i = 0; i < kSceneWidth; i++) {
|
|
for (ssize_t j = kSceneHeight-1; j >= 0; j--) {
|
|
if (clock_wise) {
|
|
scene_rot270_[c++] = kScene[j*kSceneWidth + i];
|
|
} else {
|
|
scene_rot90_[c++] = kScene[j*kSceneWidth + i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void EmulatedScene::InitializeSensorQueue() {
|
|
if (sensor_event_queue_.get() != nullptr) {
|
|
return;
|
|
}
|
|
|
|
sp<ISensorManager> manager = ISensorManager::getService();
|
|
if (manager == nullptr) {
|
|
ALOGE("%s: Cannot get ISensorManager", __func__);
|
|
} else {
|
|
bool sensor_found = false;
|
|
manager->getSensorList(
|
|
[&] (const auto& list, auto result) {
|
|
if (result != Result::OK) {
|
|
ALOGE("%s: Failed to retrieve sensor list!", __func__);
|
|
} else {
|
|
for (const SensorInfo& it : list) {
|
|
if (it.type == SensorType::ACCELEROMETER) {
|
|
sensor_found = true;
|
|
sensor_handle_ = it.sensorHandle;
|
|
}
|
|
}
|
|
}});
|
|
if (sensor_found) {
|
|
manager->createEventQueue(
|
|
new SensorHandler(this), [&](const auto& q, auto result) {
|
|
if (result != Result::OK) {
|
|
ALOGE("%s: Cannot create event queue", __func__);
|
|
return;
|
|
}
|
|
sensor_event_queue_ = q;
|
|
});
|
|
|
|
if (sensor_event_queue_.get() != nullptr) {
|
|
auto res = sensor_event_queue_->enableSensor(sensor_handle_,
|
|
ns2us(EmulatedSensor::kSupportedFrameDurationRange[0]), 0/*maxBatchReportLatencyUs*/);
|
|
if (res.isOk()) {
|
|
} else {
|
|
ALOGE("%s: Failed to enable sensor", __func__);
|
|
}
|
|
} else {
|
|
ALOGE("%s: Failed to create event queue", __func__);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void EmulatedScene::SetReadoutPixel(int x, int y) {
|
|
current_x_ = x;
|
|
current_y_ = y;
|
|
sub_x_ = (x + offset_x_ + handshake_x_) % map_div_;
|
|
sub_y_ = (y + offset_y_ + handshake_y_) % map_div_;
|
|
scene_x_ = (x + offset_x_ + handshake_x_) / map_div_;
|
|
scene_y_ = (y + offset_y_ + handshake_y_) / map_div_;
|
|
scene_idx_ = scene_y_ * kSceneWidth + scene_x_;
|
|
current_scene_material_ = &(current_colors_[current_scene_[scene_idx_]]);
|
|
}
|
|
|
|
const uint32_t* EmulatedScene::GetPixelElectrons() {
|
|
if (test_pattern_mode_) return test_pattern_data_;
|
|
|
|
const uint32_t* pixel = current_scene_material_;
|
|
current_x_++;
|
|
sub_x_++;
|
|
if (current_x_ >= sensor_width_) {
|
|
current_x_ = 0;
|
|
current_y_++;
|
|
if (current_y_ >= sensor_height_) current_y_ = 0;
|
|
SetReadoutPixel(current_x_, current_y_);
|
|
} else if (sub_x_ > map_div_) {
|
|
scene_idx_++;
|
|
scene_x_++;
|
|
current_scene_material_ = &(current_colors_[current_scene_[scene_idx_]]);
|
|
sub_x_ = 0;
|
|
}
|
|
return pixel;
|
|
}
|
|
|
|
const uint32_t* EmulatedScene::GetPixelElectronsColumn() {
|
|
const uint32_t* pixel = current_scene_material_;
|
|
current_y_++;
|
|
sub_y_++;
|
|
if (current_y_ >= sensor_height_) {
|
|
current_y_ = 0;
|
|
current_x_++;
|
|
if (current_x_ >= sensor_width_) current_x_ = 0;
|
|
SetReadoutPixel(current_x_, current_y_);
|
|
} else if (sub_y_ > map_div_) {
|
|
scene_idx_ += kSceneWidth;
|
|
scene_y_++;
|
|
current_scene_material_ = &(current_colors_[current_scene_[scene_idx_]]);
|
|
sub_y_ = 0;
|
|
}
|
|
return pixel;
|
|
}
|
|
|
|
// Handshake model constants.
|
|
// Frequencies measured in a nanosecond timebase
|
|
const float EmulatedScene::kHorizShakeFreq1 = 2 * M_PI * 2 / 1e9; // 2 Hz
|
|
const float EmulatedScene::kHorizShakeFreq2 = 2 * M_PI * 13 / 1e9; // 13 Hz
|
|
const float EmulatedScene::kVertShakeFreq1 = 2 * M_PI * 3 / 1e9; // 3 Hz
|
|
const float EmulatedScene::kVertShakeFreq2 = 2 * M_PI * 11 / 1e9; // 1 Hz
|
|
const float EmulatedScene::kFreq1Magnitude = 5;
|
|
const float EmulatedScene::kFreq2Magnitude = 1;
|
|
const float EmulatedScene::kShakeFraction =
|
|
0.03; // As a fraction of a scene tile
|
|
|
|
// Aperture of imaging lens
|
|
const float EmulatedScene::kAperture = 2.8;
|
|
|
|
// Sun illumination levels through the day
|
|
const float EmulatedScene::kSunlight[24 / kTimeStep] = {
|
|
0, // 00:00
|
|
0,
|
|
0,
|
|
kTwilightIllum, // 06:00
|
|
kDirectSunIllum,
|
|
kDirectSunIllum,
|
|
kDirectSunIllum, // 12:00
|
|
kDirectSunIllum,
|
|
kDirectSunIllum,
|
|
kSunsetIllum, // 18:00
|
|
kTwilightIllum,
|
|
0};
|
|
|
|
// Moon illumination levels through the day
|
|
const float EmulatedScene::kMoonlight[24 / kTimeStep] = {
|
|
kFullMoonIllum, // 00:00
|
|
kFullMoonIllum,
|
|
0,
|
|
0, // 06:00
|
|
0,
|
|
0,
|
|
0, // 12:00
|
|
0,
|
|
0,
|
|
0, // 18:00
|
|
0,
|
|
kFullMoonIllum};
|
|
|
|
const int EmulatedScene::kSunOverhead = 12;
|
|
const int EmulatedScene::kMoonOverhead = 0;
|
|
|
|
// Used for sun illumination levels
|
|
const float EmulatedScene::kDirectSunIllum = 100000;
|
|
const float EmulatedScene::kSunsetIllum = 400;
|
|
const float EmulatedScene::kTwilightIllum = 4;
|
|
// Used for moon illumination levels
|
|
const float EmulatedScene::kFullMoonIllum = 1;
|
|
// Other illumination levels
|
|
const float EmulatedScene::kDaylightShadeIllum = 20000;
|
|
const float EmulatedScene::kClearNightIllum = 2e-3;
|
|
const float EmulatedScene::kStarIllum = 2e-6;
|
|
const float EmulatedScene::kLivingRoomIllum = 50;
|
|
|
|
const float EmulatedScene::kIncandescentXY[2] = {0.44757f, 0.40745f};
|
|
const float EmulatedScene::kDirectSunlightXY[2] = {0.34842f, 0.35161f};
|
|
const float EmulatedScene::kDaylightXY[2] = {0.31271f, 0.32902f};
|
|
const float EmulatedScene::kNoonSkyXY[2] = {0.346f, 0.359f};
|
|
const float EmulatedScene::kMoonlightXY[2] = {0.34842f, 0.35161f};
|
|
const float EmulatedScene::kSunsetXY[2] = {0.527f, 0.413f};
|
|
|
|
const uint8_t EmulatedScene::kSelfLit = 0x01;
|
|
const uint8_t EmulatedScene::kShadowed = 0x02;
|
|
const uint8_t EmulatedScene::kSky = 0x04;
|
|
|
|
// For non-self-lit materials, the Y component is normalized with 1=full
|
|
// reflectance; for self-lit materials, it's the constant illuminance in lux.
|
|
const float EmulatedScene::kMaterials_xyY[EmulatedScene::NUM_MATERIALS][3] = {
|
|
{0.3688f, 0.4501f, .1329f}, // GRASS
|
|
{0.3688f, 0.4501f, .1329f}, // GRASS_SHADOW
|
|
{0.3986f, 0.5002f, .4440f}, // HILL
|
|
{0.3262f, 0.5040f, .2297f}, // WALL
|
|
{0.4336f, 0.3787f, .1029f}, // ROOF
|
|
{0.3316f, 0.2544f, .0639f}, // DOOR
|
|
{0.3425f, 0.3577f, .0887f}, // CHIMNEY
|
|
{kIncandescentXY[0], kIncandescentXY[1], kLivingRoomIllum}, // WINDOW
|
|
{kDirectSunlightXY[0], kDirectSunlightXY[1], kDirectSunIllum}, // SUN
|
|
{kNoonSkyXY[0], kNoonSkyXY[1], kDaylightShadeIllum / kDirectSunIllum}, // SKY
|
|
{kMoonlightXY[0], kMoonlightXY[1], kFullMoonIllum} // MOON
|
|
};
|
|
|
|
const uint8_t EmulatedScene::kMaterialsFlags[EmulatedScene::NUM_MATERIALS] = {
|
|
0, kShadowed, kShadowed, kShadowed, kShadowed, kShadowed,
|
|
kShadowed, kSelfLit, kSelfLit, kSky, kSelfLit,
|
|
};
|
|
|
|
} // namespace android
|