static void
gwy_cell_renderer_gradient_dispose(GObject *object)
{
GwyCellRendererGradient *renderer = GWY_CELL_RENDERER_GRADIENT(object);
discard_pattern(renderer);
set_gradient(renderer, NULL);
G_OBJECT_CLASS(gwy_cell_renderer_gradient_parent_class)->dispose(object);
}
line::line(pos p, pos p2, double size, gradient grad, int blending_type)
: shape(blending_type)
{
set_x(p.get_x());
set_y(p.get_y());
set_z(p.get_z());
set_x2(p2.get_x());
set_y2(p2.get_y());
set_z2(p2.get_z());
set_size(size);
set_gradient(grad);
}
JNIEXPORT jboolean JNICALL Java_com_yegorov_alexey_elements_api_ElementsStrange_gradient(JNIEnv *,
jobject, jint id, jfloat r1, jfloat g1, jfloat b1,
jfloat r2, jfloat g2, jfloat b2)
{
auto renderer = factory_.get(id);
if(renderer != nullptr)
{
renderer->set_gradient(eps::math::vec3(r1, g1, b1),
eps::math::vec3(r2, g2, b2));
return true;
}
LOGE("[API][Strange] set a gradient failed: renderer is null (%d)", id);
return false;
}
// Updates the display.
void CHistogramDlg::set_histo_channel()
{
HWND hHisto, hTags;
BOOL bInv, bMakeTotals;
LPDWORD lpHisto;
int i, j, iHisto;
LONG sum;
LONG lMaxEntry;
LPDWORD lpdw;
char szNum[40];
HWND hDlg = GetSafeHwnd();
bMakeTotals = (m_lpHistos[0] == NULL);
lpHisto = get_histo(m_lpHistos, m_wChannel, &bInv, &iHisto);
if (!lpHisto)
return;
// need to compute totals?
if (bMakeTotals)
{
for (j=0;j<5;j++)
{
lpdw = m_lpHistos[j];
sum = 0L;
for (i=0;i<256;i++)
sum += *lpdw++;
m_lTotals[j] = sum;
}
}
// setup the histo control
lMaxEntry = compute_yscale(lpHisto);
hHisto = ::GetDlgItem(hDlg, IDC_HISTOGRAM);
Histo_Init(hHisto, lpHisto, lMaxEntry, HISTOMARKS, bInv ? HTS_FLIPX:0);
// reset marks based on tag
hTags = ::GetDlgItem(hDlg, IDC_TAGS);
i = Tag_GetMark(hTags,0);
Histo_SetMark(hHisto, 0, i, NO);
i = Tag_GetMark(hTags,1);
Histo_SetMark(hHisto, 1, i, NO);
// setup the gradient
set_gradient(IDC_HISTO_GRAD, m_wChannel);
// setup readouts
::SetDlgItemText(hDlg, IDC_HISTO_TOTAL, ltoa(m_lTotals[iHisto],szNum,10));
::SetDlgItemText(hDlg, IDC_HISTO_POS, (LPSTR)"");
::SetDlgItemText(hDlg, IDC_HISTO_VALUE, (LPSTR)"");
histo_set_HMSvalues();
}
int main(void)
{
t_fire *fire;
if ((fire = bunny_malloc(sizeof(t_fire))) == NULL)
return (1);
fire->win = bunny_start(WIDTH, HEIGHT, false, "Effet de flamme uberti_l");
fire->pix = bunny_new_pixelarray(WIDTH, HEIGHT);
set_gradient(fire);
set_background(fire->pix, 0x00000000);
fixed_col(fire);
bunny_set_loop_main_function(main_loop);
bunny_loop(fire->win, 60, fire);
free_all(fire);
return (0);
}
void
SectorParser::parse_old_format(const ReaderMapping& reader)
{
m_sector.name = "main";
reader.get("gravity", m_sector.gravity);
std::string backgroundimage;
if (reader.get("background", backgroundimage) && (backgroundimage != "")) {
if (backgroundimage == "arctis.png") backgroundimage = "arctis.jpg";
if (backgroundimage == "arctis2.jpg") backgroundimage = "arctis.jpg";
if (backgroundimage == "ocean.png") backgroundimage = "ocean.jpg";
backgroundimage = "images/background/" + backgroundimage;
if (!PHYSFS_exists(backgroundimage.c_str())) {
log_warning << "Background image \"" << backgroundimage << "\" not found. Ignoring." << std::endl;
backgroundimage = "";
}
}
float bgspeed = .5;
reader.get("bkgd_speed", bgspeed);
bgspeed /= 100;
Color bkgd_top, bkgd_bottom;
int r = 0, g = 0, b = 128;
reader.get("bkgd_red_top", r);
reader.get("bkgd_green_top", g);
reader.get("bkgd_blue_top", b);
bkgd_top.red = static_cast<float> (r) / 255.0f;
bkgd_top.green = static_cast<float> (g) / 255.0f;
bkgd_top.blue = static_cast<float> (b) / 255.0f;
reader.get("bkgd_red_bottom", r);
reader.get("bkgd_green_bottom", g);
reader.get("bkgd_blue_bottom", b);
bkgd_bottom.red = static_cast<float> (r) / 255.0f;
bkgd_bottom.green = static_cast<float> (g) / 255.0f;
bkgd_bottom.blue = static_cast<float> (b) / 255.0f;
if(backgroundimage != "") {
auto background = std::make_shared<Background>();
background->set_image(backgroundimage, bgspeed);
m_sector.add_object(background);
} else {
auto gradient = std::make_shared<Gradient>();
gradient->set_gradient(bkgd_top, bkgd_bottom);
m_sector.add_object(gradient);
}
std::string particlesystem;
reader.get("particle_system", particlesystem);
if(particlesystem == "clouds")
m_sector.add_object(std::make_shared<CloudParticleSystem>());
else if(particlesystem == "snow")
m_sector.add_object(std::make_shared<SnowParticleSystem>());
else if(particlesystem == "rain")
m_sector.add_object(std::make_shared<RainParticleSystem>());
Vector startpos(100, 170);
reader.get("start_pos_x", startpos.x);
reader.get("start_pos_y", startpos.y);
auto spawn = std::make_shared<SpawnPoint>();
spawn->pos = startpos;
spawn->name = "main";
m_sector.spawnpoints.push_back(spawn);
m_sector.music = "chipdisko.ogg";
// skip reading music filename. It's all .ogg now, anyway
/*
reader.get("music", music);
*/
m_sector.music = "music/" + m_sector.music;
int width = 30, height = 15;
reader.get("width", width);
reader.get("height", height);
std::vector<unsigned int> tiles;
if(reader.get("interactive-tm", tiles)
|| reader.get("tilemap", tiles)) {
auto tileset = TileManager::current()->get_tileset(m_sector.level->get_tileset());
auto tilemap = std::make_shared<TileMap>(tileset);
tilemap->set(width, height, tiles, LAYER_TILES, true);
// replace tile id 112 (old invisible tile) with 1311 (new invisible tile)
for(size_t x=0; x < tilemap->get_width(); ++x) {
for(size_t y=0; y < tilemap->get_height(); ++y) {
uint32_t id = tilemap->get_tile_id(x, y);
if(id == 112)
tilemap->change(x, y, 1311);
}
}
if (height < 19) tilemap->resize(width, 19);
m_sector.add_object(tilemap);
}
if(reader.get("background-tm", tiles)) {
auto tileset = TileManager::current()->get_tileset(m_sector.level->get_tileset());
auto tilemap = std::make_shared<TileMap>(tileset);
tilemap->set(width, height, tiles, LAYER_BACKGROUNDTILES, false);
if (height < 19) tilemap->resize(width, 19);
m_sector.add_object(tilemap);
}
if(reader.get("foreground-tm", tiles)) {
auto tileset = TileManager::current()->get_tileset(m_sector.level->get_tileset());
auto tilemap = std::make_shared<TileMap>(tileset);
tilemap->set(width, height, tiles, LAYER_FOREGROUNDTILES, false);
// fill additional space in foreground with tiles of ID 2035 (lightmap/black)
if (height < 19) tilemap->resize(width, 19, 2035);
m_sector.add_object(tilemap);
}
// read reset-points (now spawn-points)
ReaderMapping resetpoints;
if(reader.get("reset-points", resetpoints)) {
auto iter = resetpoints.get_iter();
while(iter.next()) {
if(iter.get_key() == "point") {
Vector sp_pos;
if(reader.get("x", sp_pos.x) && reader.get("y", sp_pos.y))
{
auto sp = std::make_shared<SpawnPoint>();
sp->name = "main";
sp->pos = sp_pos;
m_sector.spawnpoints.push_back(sp);
}
} else {
log_warning << "Unknown token '" << iter.get_key() << "' in reset-points." << std::endl;
}
}
}
// read objects
ReaderCollection objects;
if(reader.get("objects", objects)) {
for(auto const& obj : objects.get_objects())
{
auto object = parse_object(obj.get_name(), obj.get_mapping());
if(object) {
m_sector.add_object(object);
} else {
log_warning << "Unknown object '" << obj.get_name() << "' in level." << std::endl;
}
}
}
// add a camera
auto camera_ = std::make_shared<Camera>(&m_sector, "Camera");
m_sector.add_object(camera_);
m_sector.update_game_objects();
if (m_sector.solid_tilemaps.empty()) {
log_warning << "sector '" << m_sector.name << "' does not contain a solid tile layer." << std::endl;
}
fix_old_tiles();
m_sector.update_game_objects();
}
void
SectorParser::parse(const ReaderMapping& sector)
{
bool has_background = false;
auto iter = sector.get_iter();
while(iter.next()) {
if(iter.get_key() == "name") {
iter.get(m_sector.name);
} else if(iter.get_key() == "gravity") {
iter.get(m_sector.gravity);
} else if(iter.get_key() == "music") {
iter.get(m_sector.music);
} else if(iter.get_key() == "spawnpoint") {
auto sp = std::make_shared<SpawnPoint>(iter.as_mapping());
if (sp->name != "" && sp->pos.x >= 0 && sp->pos.y >= 0) {
m_sector.spawnpoints.push_back(sp);
}
} else if(iter.get_key() == "init-script") {
iter.get(m_sector.init_script);
} else if(iter.get_key() == "ambient-light") {
std::vector<float> vColor;
sector.get( "ambient-light", vColor );
if(vColor.size() < 3) {
log_warning << "(ambient-light) requires a color as argument" << std::endl;
} else {
m_sector.ambient_light = Color( vColor );
}
} else {
GameObjectPtr object = parse_object(iter.get_key(), iter.as_mapping());
if(object) {
if(std::dynamic_pointer_cast<Background>(object)) {
has_background = true;
} else if(std::dynamic_pointer_cast<Gradient>(object)) {
has_background = true;
}
m_sector.add_object(object);
}
}
}
if(!has_background) {
auto gradient = std::make_shared<Gradient>();
gradient->set_gradient(Color(0.3, 0.4, 0.75), Color(1, 1, 1));
m_sector.add_object(gradient);
}
m_sector.update_game_objects();
if (m_sector.solid_tilemaps.empty()) {
log_warning << "sector '" << m_sector.name << "' does not contain a solid tile layer." << std::endl;
}
fix_old_tiles();
if (!m_sector.camera) {
log_warning << "sector '" << m_sector.name << "' does not contain a camera." << std::endl;
m_sector.update_game_objects();
m_sector.add_object(std::make_shared<Camera>(&m_sector, "Camera"));
}
m_sector.update_game_objects();
m_sector.foremost_layer = m_sector.calculate_foremost_layer();
}
// The number of users should always be a positive integer.
// The number of movies should always be a positive integer.
// The number of features should always be a positive integer.
int CollaborativeFiltering::ComputeGradient(const DataUnlabeled &ratings_data,
const DataUnlabeled &indicator_data,int num_users,int num_movies,
int num_features) {
assert(num_users >= 1);
assert(num_movies >= 1);
assert(num_features >= 1);
const int kTotalNumFeatures = num_features*(num_users+num_movies);
const arma::vec kCurrentTheta = theta();
arma::mat features_cvec = arma::zeros<arma::mat>(num_movies*num_features,1);
arma::mat params_cvec = arma::zeros<arma::mat>(num_users*num_features,1);
for(int feature_index=0; feature_index<kTotalNumFeatures; feature_index++)
{
if (feature_index < (num_users*num_features)) {
params_cvec(feature_index) = kCurrentTheta[feature_index];
}
else {
features_cvec(feature_index-(num_users*num_features)) = \
kCurrentTheta[feature_index];
}
}
arma::mat features_cvec_squared = arma::square(features_cvec);
arma::mat params_cvec_squared = arma::square(params_cvec);
arma::mat params_mat = arma::reshape(params_cvec,num_users,num_features);
arma::mat features_mat = \
arma::reshape(features_cvec,num_movies,num_features);
const arma::mat kSubsetIndicatorMat = \
indicator_data.training_features().submat(0,0,num_movies-1,num_users-1);
const arma::mat kSubsetRatingsMat = \
ratings_data.training_features().submat(0,0,num_movies-1,num_users-1);
const arma::mat kYMat = \
(arma::ones<arma::mat>(num_users,num_movies)-kSubsetIndicatorMat.t()) % \
(params_mat*features_mat.t())+kSubsetRatingsMat.t();
const arma::mat kDiffMat = (params_mat*features_mat.t()-kYMat).t();
arma::mat grad_params_arr = arma::zeros<arma::mat>(num_users*num_features,1);
arma::mat grad_params_arr_reg = \
arma::zeros<arma::mat>(num_users*num_features,1);
for(int grad_index=0; grad_index<(num_users*num_features); grad_index++)
{
int user_index = 1+(grad_index % num_users);
int feature_index = 1+((grad_index-(grad_index % num_users))/num_users);
grad_params_arr(grad_index) = \
arma::as_scalar(sum(kDiffMat.col(user_index-1) % \
features_mat.col(feature_index-1)));
grad_params_arr_reg(grad_index) = \
grad_params_arr(grad_index)+lambda_*params_cvec(grad_index);
}
arma::mat grad_features_arr = \
arma::zeros<arma::mat>(num_movies*num_features,1);
arma::mat grad_features_arr_reg = \
arma::zeros<arma::mat>(num_movies*num_features,1);
for(int grad_index=0; grad_index<(num_movies*num_features); grad_index++)
{
int movie_index = 1+(grad_index % num_movies);
int feature_index = 1+((grad_index-(grad_index % num_movies))/num_movies);
grad_features_arr(grad_index) = \
arma::as_scalar(sum(kDiffMat.row(movie_index-1) % \
(params_mat.col(feature_index-1)).t()));
grad_features_arr_reg(grad_index) = \
grad_features_arr(grad_index)+lambda_*features_cvec(grad_index);
}
arma::vec gradient_array_reg = arma::zeros<arma::vec>(kTotalNumFeatures);
gradient_array_reg.subvec(0,(num_users*num_features-1)) = \
grad_params_arr_reg;
gradient_array_reg.subvec(num_users*num_features,kTotalNumFeatures-1) = \
grad_features_arr_reg;
set_gradient(gradient_array_reg);
return 0;
}
//************************************************************************
// set_quarter_channel
// DESCRIPTION:
// Makes the given channel the current channel.
// Updates the display.
//************************************************************************
VOID CToneBalanceDlg::set_quarter_channel(WORD wChannel)
//************************************************************************
{
LPDWORD lpHisto;
HWND hControl;
BOOL bInv;
LONG lMaxEntry;
int icons[3];
HWND hDlg = GetSafeHwnd();
m_lpData->lpMap = tone_activate_channel( wChannel );
lpHisto = get_histo(m_lpData->lpHistos, wChannel, &bInv);
// setup the histo control
lMaxEntry = compute_yscale(lpHisto);
hControl = ::GetDlgItem(hDlg, IDC_HISTOGRAM);
Histo_Init(hControl, lpHisto, lMaxEntry, 3, bInv ? HTS_FLIPX:0);
m_lpData->iShadow = m_lpData->lpMap->Pnt[0].x;
m_lpData->iMidtone = m_lpData->lpMap->Pnt[1].x;
m_lpData->iHighlight = m_lpData->lpMap->Pnt[2].x;
if (!(m_lpData->iHighlight - m_lpData->iShadow))
m_lpData->MidtonePer = 0;
else
m_lpData->MidtonePer = (m_lpData->iMidtone - m_lpData->iShadow)*255/
(m_lpData->iHighlight - m_lpData->iShadow);
Histo_SetMark(hControl, 0, m_lpData->lpMap->Pnt[0].x, NO);
Histo_SetMark(hControl, 1, m_lpData->lpMap->Pnt[1].x, NO);
Histo_SetMark(hControl, 2, m_lpData->lpMap->Pnt[2].x, NO);
// some people seem to have an update problem here
::InvalidateRect (hControl,NULL,FALSE);
// setup tags
hControl = ::GetDlgItem(hDlg, IDC_TAGS);
icons[0] = IDC_QUART1;
icons[1] = IDC_QUART2;
icons[2] = IDC_QUART3;
Tag_Init(hControl, 3, 255, &icons[0]);
Tag_SetMark(hControl, 0, m_lpData->lpMap->Pnt[0].x, NO);
Tag_SetMark(hControl, 1, m_lpData->lpMap->Pnt[1].x, NO);
Tag_SetMark(hControl, 2, m_lpData->lpMap->Pnt[2].x, NO);
// some people seem to have an update problem here
::InvalidateRect (hControl,NULL,FALSE);
set_gradient(IDC_HISTO_GRAD, wChannel);
// spins
InitDlgItemSpin(hDlg, IDC_QUART1_VALUE, TO_DISPLAY(m_lpData->lpMap->Pnt[0].x), NO, 0, MAX_SPIN);
InitDlgItemSpin(hDlg, IDC_QUART3_VALUE, TO_DISPLAY(m_lpData->lpMap->Pnt[2].x), NO, 0, MAX_SPIN);
if (m_bUseMidPer)
InitDlgItemSpin(hDlg, IDC_QUART2_VALUE, m_lpData->MidtonePer*100L/255, NO, 0, MAX_SPIN );
else
InitDlgItemSpin(hDlg, IDC_QUART2_VALUE, TO_DISPLAY(m_lpData->lpMap->Pnt[1].x), NO, 0, MAX_SPIN );
InitDlgItemSpin(hDlg, IDC_MINHIGHLIGHT, TO_DISPLAY(m_lpData->lpMap->Pnt[2].y), NO, 0, MAX_SPIN);
InitDlgItemSpin(hDlg, IDC_MAXSHADOW, TO_DISPLAY(m_lpData->lpMap->Pnt[0].y), NO, 0, MAX_SPIN);
}
// The number of training examples should always be a positive integer.
int NeuralNetwork::ComputeGradient(const DataMulti &data_multi) {
const int kNumTrainEx = data_multi.num_train_ex();
assert(kNumTrainEx >= 1);
arma::mat accum_hidden_layer_grad = \
arma::zeros<arma::mat>(theta_.at(0).n_rows,\
data_multi.training_features().n_cols);
arma::mat accum_output_layer_grad = \
arma::zeros<arma::mat>(theta_.at(1).n_rows,\
theta_.at(0).n_rows+1);
// Iterates over the training examples.
for(int example_index=0; example_index<kNumTrainEx; example_index++)
{
// Performs step 1.
arma::rowvec example_features = \
data_multi.training_features().row(example_index);
arma::mat sigmoid_arg = example_features*theta_.at(0).t();
arma::mat hidden_layer_activation = ComputeSigmoid(sigmoid_arg);
const arma::mat kOnesMat = arma::ones(hidden_layer_activation.n_rows,1);
arma::mat hidden_layer_activation_mod = \
arma::join_horiz(kOnesMat,hidden_layer_activation);
sigmoid_arg = hidden_layer_activation_mod*theta_.at(1).t();
arma::mat output_layer_activation = ComputeSigmoid(sigmoid_arg);
// Performs step 2.
arma::rowvec training_labels = \
arma::zeros<arma::rowvec>(1,output_layer_size_);
int column_index = \
(int)as_scalar(data_multi.training_labels().row(example_index));
training_labels(column_index-1) = 1;
arma::colvec output_layer_error = \
(output_layer_activation-training_labels).t();
// Performs step 3.
arma::colvec hidden_layer_error_term = theta_.at(1).t()*output_layer_error;
arma::colvec hidden_layer_error = \
hidden_layer_error_term.rows(1,hidden_layer_size_) % \
ComputeSigmoidGradient((example_features*theta_.at(0).t()).t());
// Performs step 4.
accum_hidden_layer_grad = \
accum_hidden_layer_grad+hidden_layer_error*example_features;
accum_output_layer_grad = \
accum_output_layer_grad+output_layer_error*\
arma::join_horiz(arma::ones<arma::mat>(1,1),hidden_layer_activation);
}
// Performs step 5 (without regularization).
arma::mat hidden_layer_grad = (1.0/kNumTrainEx)*accum_hidden_layer_grad;
arma::mat output_layer_grad = (1.0/kNumTrainEx)*accum_output_layer_grad;
// Performs step 5 (with regularization).
hidden_layer_grad.cols(1,theta_.at(0).n_cols-1) = \
hidden_layer_grad.cols(1,theta_.at(0).n_cols-1)+\
(lambda_/kNumTrainEx)*theta_.at(0).cols(1,theta_.at(0).n_cols-1);
output_layer_grad.cols(1,theta_.at(1).n_cols-1) = \
output_layer_grad.cols(1,theta_.at(1).n_cols-1)+\
(lambda_/kNumTrainEx)*theta_.at(1).cols(1,theta_.at(1).n_cols-1);
// Sets gradient.
arma::vec hidden_layer_grad_stack = arma::vectorise(hidden_layer_grad);
arma::vec output_layer_grad_stack = arma::vectorise(output_layer_grad);
arma::vec gradient_stack = \
arma::join_vert(hidden_layer_grad_stack,output_layer_grad_stack);
set_gradient(gradient_stack);
return 0;
}
