void
double_slide_holder::
set_values
( value_type val
, value_type min
, value_type max
, value_type ss // -1 means use existing value
, value_type ps // -1 means use existing value
)
{
d_assert( ! is_setting( ));
// We generate our own signals instead of relying on the inner object.
while_setting_value_wrapper_type wrapper( this, false);
d_assert( is_setting( ));
// Remember the old values.
value_type const old_val = get_value( );
value_type const old_min = get_min_value( );
value_type const old_max = get_max_value( );
value_type const old_ss = get_single_step( );
value_type const old_ps = get_page_step( );
// Must do this before the conversions that follow.
setup_conversions( min, max);
// Send the values to the inner holder.
p_inner_holder_->
set_values
( convert_outer_to_inner( val)
, convert_outer_to_inner( min)
, convert_outer_to_inner( max)
, convert_outer_to_inner_distance( ss)
, convert_outer_to_inner_distance( ps)
);
// Find the new values. These may be slightly different due to rounding etc.
value_type const new_val = get_value( );
value_type const new_min = get_min_value( );
value_type const new_max = get_max_value( );
value_type const new_ss = get_single_step( );
value_type const new_ps = get_page_step( );
// Emit the value signals.
if ( (new_ss != old_ss) || (new_ps != old_ps) ) {
emit has_changed__steps( new_ss, new_ps);
wrapper.request_signal( );
}
if ( (new_min != old_min) || (new_max != old_max) ) {
emit has_changed__range( new_min, new_max);
wrapper.request_signal( );
}
if ( new_val != old_val ) {
emit has_changed( new_val);
wrapper.request_signal( );
}
// The wrapper dtor will signal has_changed( ) if appropriate.
wrapper.done_with_no_throws( );
}
void MemoryPool::record_peak_memory_usage() {
// Caller in JDK is responsible for synchronization -
// acquire the lock for this memory pool before calling VM
MemoryUsage usage = get_memory_usage();
size_t peak_used = get_max_value(usage.used(), _peak_usage.used());
size_t peak_committed = get_max_value(usage.committed(), _peak_usage.committed());
size_t peak_max_size = get_max_value(usage.max_size(), _peak_usage.max_size());
_peak_usage = MemoryUsage(initial_size(), peak_used, peak_committed, peak_max_size);
}
static bool
verify_contents(const struct fmt_test *test)
{
bool result = true;
unsigned amount = piglit_width * piglit_height;
unsigned short *pix = malloc (amount * 8);
glReadPixels(0, 0, piglit_width, piglit_height, GL_RGBA, test->type,
pix);
/* Setup expected value, alpha is always max in the test. */
unsigned short value[4] = { 0 };
value_for_format(test, value);
value[3] = get_max_value(test->type);
unsigned short *p = pix;
for (unsigned i = 0; i < amount; i++, p += 4) {
if (memcmp(p, value, sizeof(value)) == 0)
continue;
piglit_report_subtest_result(PIGLIT_FAIL,
"format 0x%x read fail",
test->iformat);
result = false;
break;
}
free(pix);
return result;
}
void
int_range_steps_holder::
set_min_value( value_type new_min_value)
{
// set_value_base( this, min_value_, new_min_value, & int_range_steps_holder::has_changed__min_value);
set_values( get_value( ), new_min_value, get_max_value( ));
}
float test_min_max_enhancement_old(int y,int x,int kernel_radius,IplImage * image){
vector<int> kernel_values;
for(int i=y-kernel_radius;i<=y+kernel_radius;i++){
for(int j=x-kernel_radius;j<=x+kernel_radius;j++){
if(is_coordinate_inside_boundaries(i,j,image)){
int value = get_pixel(image,i,j);
kernel_values.push_back(value);
}
}
}
float median = get_median(kernel_values);
int max_val = get_max_value(kernel_values);
int min_val = get_min_value(kernel_values);
int e = .001;
//float new_value = (float)(max_val - min_val)/(max_val + min_val + e);
//float new_value = (float)(max_val - min_val)/(median + e);
//float new_value = (float)(max_val - min_val)/(max_val + e);//seems better
float new_value = (float)(max_val - min_val)/(min_val + e);
//float new_value = (float)(max_val - min_val)/((max_val + min_val)/2 + e);
//int rvalue = (int)ceil(new_value);
//return rvalue ;
return new_value;
}
void
int_range_steps_holder::
set_page_step( value_type new_page_step)
{
// set_value_base( this, page_step_, new_page_step, & int_range_steps_holder::has_changed__page_step);
set_values( get_value( ), get_min_value( ), get_max_value( ), get_single_step( ), new_page_step);
}
/* slot */
void
double_slide_holder::
set_value( value_type new_value)
{
// set_value_base( this, value_, new_value);
set_values( new_value, get_min_value( ), get_max_value( ));
}
void
int_range_steps_holder::
set_value( value_type new_value)
{
// set_value_base( this, value_, new_value);
set_values( new_value, get_min_value( ), get_max_value( ));
}
//最长路径长度
int get_max_value (PNODE n) {
if (n == NULL) return 0;
if (n->right == NULL) {
return n->value;
} else {
return get_max_value(n->right);
}
}
void
Histogram::show_histogram()
{
IplImage* histogram_img = cvCreateImage(cvSize(get_max_value()+1,m_height),8,1);
cvZero(histogram_img);
for(int i=0;i<m_height;i++)
{
int next_value = m_histo_values[i];
int j=m_height-1;
while (CV_IMAGE_ELEM(histogram_img,uchar, j, next_value)==255)
--j;
CV_IMAGE_ELEM(histogram_img,uchar, j, next_value) = 255;
}
cvNamedWindow("Histogram",0);
cvResizeWindow("Histogram",5*get_max_value(),5*m_height);
cvShowImage("Histogram", histogram_img );
cvReleaseImage(&histogram_img);
}
void difmap::output_info(string filename, long double max, long double min, int large_ds){
ofstream infowrite;
infowrite.open(filename.c_str(), ofstream::out);
infowrite << "FILE 1 MAX: " << get_max_value(1) << endl;
infowrite << "FILE 1 MIN: " << get_min_value(1) << endl;
infowrite << "FILE 2 MAX: " << get_max_value(2) << endl;
infowrite << "FILE 2 MIN: " << get_min_value(2) << endl;
infowrite << "Max Difference: " << max << endl;
infowrite << "Min Difference: " << min << endl;
infowrite << "Range: " << (max-min) << endl;
if(large_ds != -1)
infowrite << "Dataset with largest values: " << large_ds << endl;
infowrite << "\n" << "Light green points: Values that could not be interpolated" << endl;
infowrite << "Dark green points: Divider" << endl;
}
bool
int_range_steps_holder::
is_valid( ) const
{
return
(get_min_value( ) <= get_value( )) &&
(get_value( ) <= get_max_value( )) &&
(get_single_step( ) >= 0) &&
(get_page_step( ) >= 0) &&
implies(
(get_page_step( ) > 0),
(get_page_step( ) >= get_single_step( )));
}
void
int_range_steps_holder::
move_values_to( QAbstractSlider * p_slider) const
{
d_assert( p_slider);
// The step values we store aren't necessarily the ones we give the sliders.
int page_step_slider = get_page_step( );
int single_step_slider = get_single_step( );
if ( 0 == page_step_slider ) {
page_step_slider =
(0 != single_step_slider) ?
(10 * single_step_slider) :
calc_about_an_eighth( get_max_value( ) - get_min_value( ));
}
if ( 0 == single_step_slider ) {
single_step_slider = calc_about_an_eighth( page_step_slider);
}
p_slider->setPageStep( page_step_slider);
p_slider->setSingleStep( single_step_slider);
p_slider->setRange( get_min_value( ), get_max_value( ));
p_slider->setValue( get_value( ));
}
void
int_range_steps_holder::
move_values_to( QSpinBox * p_spinb) const
{
d_assert( p_spinb);
// The single-step value we store isn't always the one we give to the spinboxes.
int single_step_spinb = get_single_step( );
if ( 0 == single_step_spinb ) {
single_step_spinb = 1;
}
p_spinb->setSingleStep( single_step_spinb);
p_spinb->setRange( get_min_value( ), get_max_value( ));
p_spinb->setValue( get_value( ));
}
SurfaceShellDensityMap::SurfaceShellDensityMap(const ParticlesTemp &ps,
float voxel_size,
IMP::FloatKey mass_key,
int num_shells)
: SampledDensityMap() {
set_kernel();
set_particles(ps, mass_key);
// update the grid size to contain all of the particles
determine_grid_size(header_.get_resolution(), voxel_size, 3.);
// to make
update_voxel_size(voxel_size);
num_shells_ = num_shells;
set_neighbor_mask();
IMP_LOG_TERSE("going to resample\n");
resample();
// update dmin and dmax
header_.dmin = get_min_value();
header_.dmax = get_max_value();
}
static bool
verify_contents_float(const struct fmt_test *test)
{
/* Setup expected value, alpha is always max in the test. */
unsigned short value[4] = { 0 };
unsigned short max = get_max_value(test->type);
value_for_format(test, value);
value[3] = max;
const float expected[4] = {
value[0] / max,
value[1] / max,
value[2] / max,
value[3] / max,
};
bool res = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
expected);
return res;
}
static void
value_for_format(const struct fmt_test *test, unsigned short *value)
{
unsigned short val = get_max_value(test->type);
/* red */
value[0] = val;
/* yellow */
if (test->bpp > 2)
value[1] = val;
/* pink */
if (test->bpp > 4) {
value[2] = val;
value[1] = 0;
}
/* blue */
if (test->bpp > 6) {
value[3] = val;
value[0] = 0;
}
}
static bool
buffer_test(const struct fmt_test *test)
{
GLuint tex, tbo;
/* Setup expected value, alpha is always max in the test. */
unsigned short tbo_data[4] = { 0 };
value_for_format(test, tbo_data);
tbo_data[3] = get_max_value(test->type);
glGenBuffers(1, &tbo);
glBindBuffer(GL_TEXTURE_BUFFER, tbo);
glBufferData(GL_TEXTURE_BUFFER, sizeof(tbo_data), tbo_data,
GL_STATIC_DRAW);
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_BUFFER, tex);
glTexBuffer(GL_TEXTURE_BUFFER, test->iformat, tbo);
if (!piglit_check_gl_error(GL_NO_ERROR))
return false;
glUseProgram(buf_prog);
glUniform1i(0 /* explicit loc */, 0);
render_texture(tex, GL_TEXTURE_BUFFER, 0);
if (!verify_contents_float(test))
return false;
piglit_present_results();
glDeleteTextures(1, &tex);
glBindBuffer(GL_TEXTURE_BUFFER, 0);
return true;
}
int main() {
char buf[50];
int option;
PNODE tree = NULL;
PNODE node = NULL;
while (1) {
printf ("--------------------------\n");
printf ("Options are:\n\n");
printf (" 0 Exit\n");
printf (" 1 Insert node\n");
printf (" 2 Delete node\n");
printf (" 3 Find node\n");
printf (" 4 Pre order traversal\n");
printf (" 5 In order traversal\n");
printf (" 6 Post order traversal\n");
printf (" 7 Max depth\n");
printf (" 8 Min depth\n");
printf (" 9 Max value\n");
printf (" 10 Min value\n");
printf (" 11 Node Count\n\n");
printf ("--------------------------\n");
printf ("Select an option: ");
fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("--------------------------\n");
if (option < 0 || option > 11) {
fprintf (stderr, "Invalid option");
continue;
}
switch (option) {
case 0:
exit (0);
case 1:
printf ("Enter number to insert: ");
fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("\n\n");
insert_node (&tree, option);
break;
case 2:
printf ("Enter number to delete: ");
fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("\n\n");
delete_node (&tree, option);
break;
case 3:
printf ("Enter number to find: ");
fgets (buf, sizeof(buf), stdin);
sscanf (buf, "%i", &option);
printf ("\n\n");
node = find_node (tree, option);
if (node != NULL) {
printf ("Found node\n\n");
} else {
printf ("Couldn't find node\n\n");
}
break;
case 4:
printf ("Pre order traversal: ");
pre_order_traversal (tree);
printf ("\n\n");
break;
case 5:
printf ("In order traversal: ");
in_order_traversal (tree);
printf ("\n\n");
break;
case 6:
printf ("Post order traversal: ");
post_order_traversal (tree);
printf ("\n\n");
break;
case 7:
printf ("Max depth is %i\n\n", get_max_depth (tree));
break;
case 8:
printf ("Min depth is %i\n\n", get_min_depth (tree));
break;
case 9:
printf ("Max value is %i\n\n", get_max_value (tree));
break;
case 10:
printf ("Min value is %i\n\n", get_min_value (tree));
break;
case 11:
printf ("Node Count is %i\n\n", get_num_nodes (tree));
break;
}
}
return 0;
}
/* slot */
void
double_slide_holder::
set_steps( value_type single_step, value_type page_step)
{
set_values( get_value( ), get_min_value( ), get_max_value( ), single_step, page_step);
}
string colmap::compare(){
string ret("");
indexed_points *ds1_ip = dynamic_cast<indexed_points*>(dataset1);
indexed_points *ds2_ip = dynamic_cast<indexed_points*>(dataset2);
if(ds1_ip == NULL || ds2_ip == NULL)
return string("Improper Datasets");
for(int j=1; j<=2; j++){
long double max = get_max_value(j);
long double min = get_min_value(j);
long double range = max - min;
int x_size = 0;
int y_size = 0;
int z_size = 0;
if(j == 1){
x_size = ds1_ip->get_dim().sizes[0];
y_size = ds1_ip->get_dim().sizes[1];
z_size = ds1_ip->get_dim().sizes[2];
}
else{
x_size = ds2_ip->get_dim().sizes[0];
y_size = ds2_ip->get_dim().sizes[1];
z_size = ds2_ip->get_dim().sizes[2];;
}
CImg<unsigned char> imgOut(x_size, y_size, z_size, 3, 0);
for(int x=0; x<x_size; x++){
for(int y=0; y<y_size; y++){
for(int z=0; z<z_size; z++){
layout loc;
loc.arr_size = 3;
loc.sizes = new int[3];
loc.sizes[0] = x;
loc.sizes[1] = y;
loc.sizes[2] = z;
long double pt_val;
if(j == 1)
pt_val = ds1_ip->get_indexed_point(loc).vals[var_ds1];
else if(j == 2)
pt_val = ds2_ip->get_indexed_point(loc).vals[var_ds2];
rgb_color col = get_color_single_sided(pt_val, range, min);
imgOut(x, y_size - y - 1, z, 0) = col.r;
imgOut(x, y_size - y - 1, z, 1) = col.g;
imgOut(x, y_size - y - 1, z, 2) = col.b;
}
}
}
//Construct file name
string output_name(outprefix);
output_name += "_colmap";
if(j == 1){
output_name += "_FIRST_";
output_name += "var1_";
output_name += itoa(var_ds1);
}
else if(j == 2){
output_name += "_SECOND_";
output_name += "var2_";
output_name += itoa(var_ds2);
}
output_name += ".bmp";
ret += output_name + " ";
imgOut.save_bmp(output_name.c_str());
}
return ret;
}
/* slot */
void
double_slide_holder::
set_min_value( value_type new_min_value)
{
set_values( get_value( ), new_min_value, get_max_value( ));
}
/* slot */
void
double_slide_holder::
set_page_step( value_type new_page_step)
{
set_values( get_value( ), get_min_value( ), get_max_value( ), get_single_step( ), new_page_step);
}
double GRN::DNASeqAlignment(std::string query, int query_size,
std::string subject, int subject_size) {
// Linear gap penalty when inserts a space in query sequence.
double G_ = GAP_2;
// Linear gap penalty when inserts a space in subject sequence.
double _G = GAP_2;
// Records the length of query sequence after alignment.
int query_length = 0;
// Records the length of subject sequence after aligment.
int subject_length = 0;
// The number of matches and similar matches in alignment. When it's divided
// by query_length or subject_length, it means the percentage similariy.
double positives = 0;
query_length = query_size;
subject_length = subject_size;
// Records longest common subsequence.
std::string common_subsequence;
// Records query sequence after alignment.
std::string query_sub;
// Records subject sequence after alignment.
std::string subject_sub;
// Score matrix of dynamic planning.
//
// Sets query sequence to be X axis.
// Sets subject sequence to be Y axis.
std::vector< std::vector<double> > align_matrix
(subject_size + 1, std::vector<double>(query_size + 1));
// Initialize score matrix.
//
// Sets (0, 0) to be 0.
// (i, 0) = (i - 1, 0) + gap penalty.
// (0, j) = (0, j - 1) + gap penalty.
align_matrix[0][0] = 0;
for (int i = 1; i != subject_size + 1; ++i) {
align_matrix[i][0] = align_matrix[i - 1][0] + G_;
}
for (int j = 1; j != query_size + 1; ++j) {
align_matrix[0][j] = align_matrix[0][j - 1] + _G;
}
// Dynamic planning.
//
// There are 3 possible paths moving to (i, j) element in score matrix:
// (1) Diagonal:
// (i, j) = (i - 1, j - 1) + (subject[i] vs. query[j]).
// It means a match or a similar match according to BLOSUM_50.
// (2) Vertical:
// (i, j) = (i - 1, j) + (subject[i] vs. a space in query[j]).
// It means inserting a space in query sequence.
// (3) Horizontal:
// (i, j) = (i, j - 1) + (a space in subject[i] vs. query[j]).
// It means inserting a space in subject sequence.
// Chooses the maximum of the three as the actual path.
for (int i = 1; i != subject_size + 1; ++i) {
for (int j = 1; j != query_size + 1; ++j) {
double st = 0;
double s_ = 0;
double _t = 0;
st = align_matrix[i - 1][j - 1] +
DNASequenceAlignScore(subject[i], query[j]);
_t = align_matrix[i - 1][j] +
DNASequenceAlignScore(subject[i], ' ');
s_ = align_matrix[i][j - 1] +
DNASequenceAlignScore(' ', query[j]);
align_matrix[i][j] = get_max_value(st, s_, _t);
}
}
// Trace back.
//
// Finds the longest common sequence and records the length of query
// sequence and the length of subject sequence after alignment.
// The trace begins at the last element in the score matrix and ends at
// the first element in the score matrix.
for (int i = subject_size, j = query_size; (i > 0 || j > 0);) {
if ((i * j > 0) && (align_matrix[i][j] == align_matrix[i - 1][j - 1] +
DNASequenceAlignScore(subject[i], query[j]))) {
if (query[j] == subject[i]) {
common_subsequence += query[j];
query_sub += query[j];
subject_sub += subject[i];
} else {
query_sub += query[j];
subject_sub += subject[i];
}
i--;
j--;
} else if ((i > 0) && (align_matrix[i][j] == align_matrix[i - 1][j] +
DNASequenceAlignScore(subject[i], ' '))) {
// Insert a space in query sequence.
query_length += 1;
query_sub += '-';
subject_sub += subject[i];
i--;
} else if ((j > 0) && (align_matrix[i][j] == align_matrix[i][j - 1] +
DNASequenceAlignScore(' ', query[j]))) {
// Insert a space in subject sequence.
subject_length += 1;
subject_sub += '-';
query_sub += query[j];
j--;
}
}
// Calculates the percentage simialrity.
positives = (double)common_subsequence.size() / query_length;
return positives;
}
void
int_range_steps_holder::
set_values
( value_type val
, value_type min
, value_type max
, value_type ss // = -1
, value_type ps // = -1
)
{
d_assert( is_valid( ));
// Use existing values if negative steps specified.
if ( ss < 0 ) { ss = get_single_step( ); }
if ( ps < 0 ) { ps = get_page_step( ); }
// Make sure the new values are valid. Min and single-step never change here.
if ( max < min ) { max = min; }
if ( val < min ) { val = min; }
if ( val > max ) { val = max; }
if ( (0 != ps) && (ps < ss) ) { ps = ss; }
// Find out what's going to change.
bool const is_changed__val = (value_ != val);
bool const is_changed__min = (min_value_ != min);
bool const is_changed__max = (max_value_ != max);
bool const is_changed__ss = (single_step_ != ss );
bool const is_changed__ps = (page_step_ != ps );
// We're done if nothing is changing.
if ( is_changed__val ||
is_changed__min ||
is_changed__max ||
is_changed__ss ||
is_changed__ps )
{
if ( is_setting( ) ) {
d_assert( false);
} else {
while_setting_value_wrapper_type wrapper( this);
// Set the values in this holder.
if ( is_changed__val ) { value_ = val; }
if ( is_changed__min ) { min_value_ = min; }
if ( is_changed__max ) { max_value_ = max; }
if ( is_changed__ss ) { single_step_ = ss ; }
if ( is_changed__ps ) { page_step_ = ps ; }
d_assert( is_valid( ));
// Loop thru all the attached widgets (spinboxes and sliders).
// We don't have to relay our has_changed.. signals to these ctrls because we
// keep them in sync here.
list_type::iterator iter = attached_widgets_.begin( );
list_type::iterator const iter_limit = attached_widgets_.end( );
while ( iter != iter_limit ) {
QWidget * p_widget = *iter;
d_assert( p_widget);
QSpinBox * p_spinb = qobject_cast< QSpinBox * >( p_widget);
if ( p_spinb ) {
move_values_to( p_spinb);
} else {
QAbstractSlider * p_slider = qobject_cast< QAbstractSlider * >( p_widget);
d_assert( p_slider);
move_values_to( p_slider);
}
++ iter;
}
// Emit the value signals. The has_changed( ) signal with no args will be emitted last.
if ( is_changed__ss || is_changed__ps ) {
emit has_changed__steps( get_single_step( ), get_page_step( ));
}
if ( is_changed__min || is_changed__max ) {
emit has_changed__range( get_min_value( ), get_max_value( ));
}
if ( is_changed__val ) {
emit has_changed( get_value( ));
}
// The dtor for this wrapper emits the has_changed( ) signal.
wrapper.done_with_no_throws( );
}
}
d_assert( is_valid( ));
}
void
int_range_steps_holder::
set_steps( value_type single_step, value_type page_step)
{
set_values( get_value( ), get_min_value( ), get_max_value( ), single_step, page_step);
}
