void calculate_areas(polygon_t *polygons[], int num_of_polygons) {
int i;
for (i = 0; i < num_of_polygons; ++i) {
calculate_area(polygons[i]);
}
}
double IsoperimetricProblem::calculate_objective(void)
{
double perimeter_error = calculate_perimeter_error();
double area = calculate_area();
return(-1.0*area_weight*area + perimeter_error_weight*pow(perimeter_error,2));
}
void IsoperimetricProblem::print_information(void)
{
double perimeter_error = calculate_perimeter_error();
double area = calculate_area();
std::cout << "Perimeter error: " << perimeter_error << std::endl
<< "Area: " << area << std::endl;
}
static bool is_wide_gamut(const skcms_ICCProfile& profile) {
// Determine if the source image has a gamut that is wider than sRGB. If so, we
// will use P3 as the output color space to avoid clipping the gamut.
if (profile.has_toXYZD50) {
SkPoint rgb[3];
load_gamut(rgb, profile.toXYZD50);
return calculate_area(rgb) > kSRGB_D50_GamutArea;
}
return false;
}
void
DrawOpBuffer::render(SDLFramebuffer& fb, DrawOpBuffer& frontbuffer)
{
if (!buffer_equal(frontbuffer, *this))
{
std::vector<Rect> changed_regions;
buffer_difference(frontbuffer, *this, changed_regions);
// Clip things to the screen
Size screen_size = fb.get_size();
for(std::vector<Rect>::iterator i = changed_regions.begin(); i != changed_regions.end(); ++i)
{
// FIXME: It might be a good idea to remove empty rectangles here, so that merge_rectangles() can work smoother
i->left = Math::clamp(0, int(i->left), screen_size.width);
i->top = Math::clamp(0, int(i->top), screen_size.height);
i->right = Math::clamp(0, int(i->right), screen_size.width);
i->bottom = Math::clamp(0, int(i->bottom), screen_size.height);
}
if (!changed_regions.empty())
{
// Merge rectangles
std::vector<Rect> update_rects;
merge_rectangles(changed_regions, update_rects);
int area = calculate_area(update_rects);
if (area < fb.get_size().get_area()*75/100) // FIXME: Random Magic ratio, need benchmarking to find proper value
{ // Update all regions that need update
for(std::vector<Rect>::iterator i = update_rects.begin(); i != update_rects.end(); ++i)
{
// draw things
fb.push_cliprect(*i);
for(DrawOps::iterator j = draw_ops.begin(); j != draw_ops.end(); ++j)
{
(*j)->render(fb);
}
fb.pop_cliprect();
}
fb.update_rects(update_rects);
}
else
{ // Update the whole screen at once, since we have to many rects
for(DrawOps::iterator j = draw_ops.begin(); j != draw_ops.end(); ++j)
(*j)->render(fb);
fb.flip();
}
}
}
}
static void draw_gamut(SkCanvas* canvas, const SkMatrix44& xyz, const char* name, SkColor color,
bool label) {
// Report the XYZ values.
SkDebugf("%s\n", name);
SkDebugf(" X Y Z\n");
SkDebugf("Red %.3f %.3f %.3f\n", xyz.get(0, 0), xyz.get(0, 1), xyz.get(0, 2));
SkDebugf("Green %.3f %.3f %.3f\n", xyz.get(1, 0), xyz.get(1, 1), xyz.get(1, 2));
SkDebugf("Blue %.3f %.3f %.3f\n", xyz.get(2, 0), xyz.get(2, 1), xyz.get(2, 2));
// Calculate the points in the gamut from the XYZ values.
SkPoint rgb[4];
load_gamut(rgb, xyz);
// Report the area of the gamut.
SkDebugf("Area of Gamut: %.3f\n\n", calculate_area(rgb));
// Magic constants that help us place the gamut triangles in the appropriate position
// on the canvas.
const float xScale = 2071.25f; // Num pixels from 0 to 1 in x
const float xOffset = 241.0f; // Num pixels until start of x-axis
const float yScale = 2067.78f; // Num pixels from 0 to 1 in y
const float yOffset = -144.78f; // Num pixels until start of y-axis
// (negative because y extends beyond image bounds)
// Now transform the points so they can be drawn on our canvas.
// Note that y increases as we move down the canvas.
rgb[0].fX = xOffset + xScale * rgb[0].fX;
rgb[0].fY = yOffset + yScale * (1.0f - rgb[0].fY);
rgb[1].fX = xOffset + xScale * rgb[1].fX;
rgb[1].fY = yOffset + yScale * (1.0f - rgb[1].fY);
rgb[2].fX = xOffset + xScale * rgb[2].fX;
rgb[2].fY = yOffset + yScale * (1.0f - rgb[2].fY);
// Repeat the first point to connect the polygon.
rgb[3] = rgb[0];
SkPaint paint;
paint.setColor(color);
paint.setStrokeWidth(6.0f);
paint.setTextSize(75.0f);
canvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, rgb, paint);
if (label) {
canvas->drawText("R", 1, rgb[0].fX + 5.0f, rgb[0].fY + 75.0f, paint);
canvas->drawText("G", 1, rgb[1].fX + 5.0f, rgb[1].fY - 5.0f, paint);
canvas->drawText("B", 1, rgb[2].fX - 75.0f, rgb[2].fY - 5.0f, paint);
}
}
void test_features(int feature) {
SDL_Surface* image =
load_image("dataset/newface24/face24_001000.bmp");
features_array_t* features = alloc_features_array();
integral_image_t* integral_image = alloc_integral_image(image->w, image->h);
convert_to_integral_image(image, integral_image);
compute_haar_features_vector(features, integral_image);
Int64 sum = 0;
for (int i = 5; i < 12; ++i) {
for (int j = 2; j < 5; ++j) {
sum += getpixel(image, i, j);
}
}
printf("%lli == %lli\n", sum, calculate_area(5, 2, 12, 5, integral_image));
printf("size=%d features[%d]=%lli\n", features->size, feature, features->features[feature].value);
free_features_array(features);
free_integral_image(integral_image);
SDL_FreeSurface(image);
}
int read_my_testcase(char *cells_file,char *nets_file, char *area_file, double *chip_width, double *chip_height)
{
FILE *cells, *area, *nets;
char buffer[MAX_LINE_CHARS] = {0,};
double utilization = 0;
cells = fopen(cells_file, "r");
if (cells == NULL) {
printf("Could not open cells file.");
return 1;
}
while (fgets(buffer, MAX_LINE_CHARS, cells) != NULL) {
create_lists_depending_on_type(buffer);
}
fclose(cells);
area = fopen(area_file, "r");
if(area != NULL) {
fscanf(area,"chip height = %lf chip width = %lf", chip_height, chip_width);
fclose(area);
}
else {
printf("No area file given. Calculating area form circuit.\n");
scanf("%lf", &utilization);
calculate_area(chip_width, chip_height, utilization);
init_pins(*chip_width, *chip_height);
}
nets = fopen(nets_file, "r");
if(nets == NULL) {
printf("Could not open nets file.\n");
return 1;
}
while (fgets(buffer, MAX_LINE_CHARS, nets) != NULL) {
create_net_list(buffer);
}
fclose(nets);
return 0;
}
object *baseline(unsigned char *image, unsigned char *mask, int width, int height, int *n_object)
{
int i = 0, j = 0, k = 0;
int n; /* number of objects */
int *area; /* area */
double *len; /* perimeter length */
double *circ; /* circularity index */
double *input_val;
/*Color features*/
double *clr_mn_value, *clr_std_dev, *clr_skew, *clr_kurtosis, **clr_hist;
/*Texture features*/
double ***glcmat, *ang_sec_mom, *contr, *corr, *var;
double *inv_diff_mom, *sum_av, *sum_entrp, *sum_varnc;
double *entrp, *diff_var, *diff_entrp;
object *obj; /* for storing results */
int **obj_id = (int **)malloc(height*sizeof(int *));
if (obj_id == NULL){
printf("Could not allocate %d bytes.\n", height*sizeof(int *));
exit(0);
}
else{
for (i = 0; i < height; i++){
obj_id[i] = (int *)malloc(width*sizeof(int));
if (obj_id[i] == NULL){
printf("Could not allocate %d bytes for i=%d index.\n", width*sizeof(int), i);
exit(0);
}
}
}
/* assign ID to each object and returns the number of objects */
n = assign_id(mask, width, height, obj_id);
/* allocate memories */
area = (int *)malloc(n * sizeof(int));
if (area == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(int)));
exit(-1);
}
len = (double *)malloc(n * sizeof(double));
if (len == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
circ = (double *)malloc(n * sizeof(double));
if (circ == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
obj = (object *)malloc(n * sizeof(object));
if (obj == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(object)));
exit(-1);
}
/*Colors*/
clr_mn_value = (double *)malloc(n * sizeof(double));
if (clr_mn_value == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
input_val = (double *)malloc(n * sizeof(double));
if (input_val == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
clr_std_dev = (double *)malloc(n * sizeof(double));
if (clr_std_dev == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
clr_skew = (double *)malloc(n * sizeof(double));
if (clr_skew == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
clr_kurtosis = (double *)malloc(n * sizeof(double));
if (clr_kurtosis == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
clr_hist = (double **)malloc(n*sizeof(double *));
if (clr_hist == NULL){
printf("Could not allocate %d bytes.\n", n*sizeof(double *));
exit(0);
}
else{
for (i = 0; i < n; i++){
clr_hist[i] = (double *)malloc(256*sizeof(double));
if (clr_hist[i] == NULL){
printf("Could not allocate %d bytes for i=%d index.\n", 256*sizeof(double), i);
exit(0);
}
else{
for (j = 0; j<256; j++){
clr_hist[i][j] = 0.0;
}
}
}
}
/*Texture*/
glcmat = (double ***)malloc(n * sizeof(double**));
if (glcmat == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double**)));
exit(-1);
}
else{
for (i = 0;i < n; i++){
glcmat[i] = (double **)malloc(256 * sizeof(double *));
if (glcmat[i] == NULL){
printf("Cannot allocate %d bytes for memory.\n", (256 * sizeof(double *)));
exit(-1);
}
else{
for (j = 0;j < 256; j++){
glcmat[i][j] = (double *)malloc(256 * sizeof(double));
if (glcmat[i][j] == NULL){
printf("Cannot allocate %d bytes for memory.\n", (256 * sizeof(double)));
exit(-1);
}
else{
for (k = 0;k < 256;k++){
glcmat[i][j][k] = 0.0;
}
}
}/*for j*/
}
}/*for i*/
}
ang_sec_mom = (double *)malloc(n * sizeof(double));
if (ang_sec_mom == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(ang_sec_mom, 0, (n * sizeof(double)));
contr = (double *)malloc(n * sizeof(double));
if (contr == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(contr, 0, (n * sizeof(double)));
corr = (double *)malloc(n * sizeof(double));
if (corr == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(corr, 0, (n * sizeof(double)));
var = (double *)malloc(n * sizeof(double));
if (var == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(var, 0, (n * sizeof(double)));
inv_diff_mom = (double *)malloc(n * sizeof(double));
if (inv_diff_mom == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(inv_diff_mom, 0, (n * sizeof(double)));
sum_av = (double *)malloc(n * sizeof(double));
if (sum_av == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(sum_av, 0, (n * sizeof(double)));
sum_entrp = (double *)malloc(n * sizeof(double));
if (sum_entrp == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(sum_entrp, 0, (n * sizeof(double)));
sum_varnc = (double *)malloc(n * sizeof(double));
if (sum_varnc == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(sum_varnc, 0, (n * sizeof(double)));
entrp = (double *)malloc(n * sizeof(double));
if (entrp == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(entrp, 0, (n * sizeof(double)));
diff_var = (double *)malloc(n * sizeof(double));
if (diff_var == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(diff_var, 0, (n * sizeof(double)));
diff_entrp = (double *)malloc(n * sizeof(double));
if (diff_entrp == NULL){
printf("Cannot allocate %d bytes for memory.\n", (n * sizeof(double)));
exit(-1);
}
memset(diff_entrp, 0, (n * sizeof(double)));
/* calcuate areas */
calculate_area(obj_id, width, height, n, area);
/* calcuate perimeter length */
calculate_length(obj_id, width, height, n, len, image);
/* calcuate cirularity index */
/*
morphological_feature_circularity_index(area, len, n, circ);
morphological_feature_object_moment(1.0, 1.0, obj_id, width, height, n, image, circ);
morphological_feature_central_moments(0.0, 0.0, obj_id, width, height, n, image, circ);
morphological_feature_object_orientation(obj_id, width, height, n, image, circ);
*/
morphological_feature_object_eccentricity(obj_id, width, height, n, image, circ);
/*
morphological_feature_central_invariant_moments(1.0, 1.0, obj_id, width, height, n, image, circ);
*/
/*color features*/
/*
color_feature_mean(obj_id, width, height, n, area, image, clr_mn_value);
color_feature_standard_deviation(obj_id, width, height, n, area, image, clr_mn_value, clr_std_dev);
color_feature_skewness(obj_id, width, height, n, area, image, clr_mn_value, clr_skew);
color_feature_kurtosis(obj_id, width, height, n, area, image, clr_mn_value, clr_kurtosis);
color_feature_histogram(0, obj_id, width, height, n, area, image, clr_hist);
*/
/*texture features*/
/*
glcm(0, obj_id, width, height, n, image, glcmat);
texture_feature_angular_second_moment(glcmat, n, ang_sec_mom);
texture_feature_contrast(glcmat, n, contr);
texture_feature_correlation(glcmat, n, corr);
texture_feature_variance(glcmat, n, var);
texture_feature_inverse_diff_moment(glcmat, n, inv_diff_mom);
texture_feature_sum_average(glcmat, n, sum_av);
texture_feature_sum_entropy(glcmat, n, sum_entrp);
texture_feature_sum_variance(glcmat, n, sum_entrp, sum_varnc);
texture_feature_entropy(glcmat, n, entrp);
texture_feature_difference_variance(glcmat, n, diff_var);
texture_feature_difference_entropy(glcmat, n, diff_entrp);
*/
double weight = 0.0;
for (i = 0; i < n; i++) {
/*Morphological feature*/
input_val[i] = circ[i];
/*Color features*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_mn_value[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_std_dev[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_skew[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*clr_kurtosis[i];*/
/*input_val[i] = weight*circ[i] + weight*clr_mn_value[i] + weight*clr_std_dev[i] + weight*clr_skew[i] + weight*clr_kurtosis[i];*/
/*input_val[i] = weight*clr_mn_value[i] + weight*clr_std_dev[i] + weight*clr_skew[i] + weight*clr_kurtosis[i];*/
/*Texture features*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*ang_sec_mom[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*contr[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*corr[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*var[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*inv_diff_mom[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*sum_av[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*sum_entrp[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*sum_varnc[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*entrp[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*diff_var[i];*/
/*input_val[i] = weight*circ[i] + (1.0 - weight)*diff_entrp[i];*/
}
/* k-means clustering */
/*k_means(circ, obj, n);*/
k_means(input_val, obj, n);
/* choose representatives (smallest number for each cluster) */
for (i = 0; i < n; i++) obj[i].rep = 0;
for (j = 0; j < NUM_CLASS; j++) {
for (i = 0; i < n; i++) {
if (obj[i].label == j) {
obj[i].rep = 1;
break;
}
}
}
/* find bounding box */
find_rect(obj_id, width, height, n, obj);
for (i = 0; i < height; i++) free(obj_id[i]);
free(obj_id);
free(area);
free(len);
free(circ);
free(input_val);
/*color features*/
free(clr_mn_value);
free(clr_std_dev);
free(clr_skew);
free(clr_kurtosis);
for (i = 0; i < n; i++)
free(clr_hist[i]);
free(clr_hist);
/*texture features*/
for (i=0;i<n;i++){
for (j=0;j<256;j++){
free(glcmat[i][j]);
}/*for j*/
free(glcmat[i]);
}/*for i*/
free(glcmat);
free(ang_sec_mom);
free(contr);
free(corr);
free(var);
free(inv_diff_mom);
free(sum_av);
free(sum_entrp);
free(sum_varnc);
free(entrp);
free(diff_var);
free(diff_entrp);
*n_object = n;
return obj;
}
void
xcacti_power_flp (const result_type * result,
const arearesult_type * ar,
const area_type * arearesult_subbanked,
const parameter_type * parameters, xcacti_flp * xflp)
{
//---------------------------------------
// area calculations
double data_array_area =
calculate_area (ar->dataarray_area, parameters->fudgefactor);
double tag_array_area =
calculate_area (ar->tagarray_area, parameters->fudgefactor);
double decode_area =
calculate_area (ar->datapredecode_area,
parameters->fudgefactor) +
calculate_area (ar->tagpredecode_area, parameters->fudgefactor);
double data_ctrl_area =
calculate_area (ar->datacolmuxpredecode_area,
parameters->fudgefactor) +
calculate_area (ar->datacolmuxpostdecode_area,
parameters->fudgefactor) +
calculate_area (ar->datawritesig_area, parameters->fudgefactor);
double tag_ctrl_area =
calculate_area (ar->tagcolmuxpredecode_area,
parameters->fudgefactor) +
calculate_area (ar->tagcolmuxpostdecode_area,
parameters->fudgefactor) +
calculate_area (ar->tagoutdrvdecode_area,
parameters->fudgefactor) +
calculate_area (ar->tagoutdrvsig_area, parameters->fudgefactor);
// if (parameters->fully_assoc || parameters->ignore_tag) {
if (parameters->fully_assoc || parameters->force_tag)
{
tag_ctrl_area = 0;
tag_array_area = 0;
}
double total_area = data_array_area + tag_array_area + decode_area +
data_ctrl_area + tag_ctrl_area;
#if 0
double bank_ctrl_area = ar->totalarea -
calculate_area (ar->dataarray_area, parameters->fudgefactor) -
calculate_area (ar->tagarray_area, parameters->fudgefactor);
#else
double bank_ctrl_area =
calculate_area (*arearesult_subbanked,
parameters->fudgefactor) -
(parameters->NSubbanks) * (total_area);
#endif
bank_ctrl_area /= parameters->NSubbanks;
total_area += bank_ctrl_area;
//---------------------------------------
// Energy calculations
double data_array_e = result->wordline_power_data.readOp.dynamic +
result->bitline_power_data.readOp.dynamic;
double data_ctrl_e = result->sense_amp_power_data.readOp.dynamic +
result->data_output_power.readOp.dynamic +
result->total_out_driver_power_data.readOp.dynamic;
double decode_e;
double tag_array_e;
double tag_ctrl_e;
// if (parameters->fully_assoc || parameters->ignore_tag) {
if (parameters->fully_assoc || parameters->force_tag)
{
decode_e = result->decoder_power_data.readOp.dynamic;
tag_ctrl_e = 0;
tag_array_e = 0;
}
else
{
tag_array_e = result->wordline_power_tag.readOp.dynamic +
result->bitline_power_tag.readOp.dynamic;
decode_e = result->decoder_power_data.readOp.dynamic +
result->decoder_power_tag.readOp.dynamic;
tag_ctrl_e = result->sense_amp_power_tag.readOp.dynamic +
result->compare_part_power.readOp.dynamic +
result->drive_valid_power.readOp.dynamic +
result->drive_mux_power.readOp.dynamic +
result->selb_power.readOp.dynamic;
}
double bank_ctrl_e = result->subbank_address_routing_power.readOp.dynamic;
#if 0
printf ("decode %6.3g%% %9.3fpJ\n", 100 * decode_area / total_area,
decode_e * PICOJ);
printf ("tag array %6.3g%% %9.3fpJ\n", 100 * tag_array_area / total_area,
tag_array_e * PICOJ);
printf ("tag ctrl %6.3g%% %9.3fpJ\n", 100 * tag_ctrl_area / total_area,
tag_ctrl_e * PICOJ);
printf ("data array %6.3g%% %9.3fpJ\n", 100 * data_array_area / total_area,
data_array_e * PICOJ);
printf ("data ctrl %6.3g%% %9.3fpJ\n", 100 * data_ctrl_area / total_area,
data_ctrl_e * PICOJ);
printf ("bank ctrl %6.3g%% %9.3fpJ\n", 100 * bank_ctrl_area / total_area,
bank_ctrl_e * PICOJ);
#endif
//---------------------------------------
// Area Readjustments based on power densities
double factor = 15;
// readjust areas so that no block has a power density 20x the data array (%)
double data_array_pd = data_array_e / data_array_area;
double data_ctrl_pd = data_ctrl_e / data_ctrl_area;
if (data_ctrl_pd > factor * data_array_pd)
{
data_ctrl_area = data_ctrl_e / (factor * data_array_pd);
}
double tag_array_pd;
double tag_ctrl_pd;
// if (parameters->fully_assoc || parameters->ignore_tag) {
if (parameters->fully_assoc || parameters->force_tag)
{
tag_array_pd = 0;
tag_ctrl_pd = 0;
}
else
{
tag_array_pd = tag_array_e / tag_array_area;
if (tag_array_pd > factor * data_array_pd)
{
tag_array_area = tag_array_e / (factor * data_array_pd);
}
tag_ctrl_pd = tag_ctrl_e / tag_array_area;
if (tag_ctrl_pd > factor * data_array_pd)
{
tag_ctrl_area = tag_ctrl_e / (factor * data_array_pd);
}
}
double decode_pd = decode_e / decode_area;
if (decode_pd > factor * data_array_pd)
{
decode_area = decode_e / (factor * data_array_pd);
}
double bank_ctrl_pd = bank_ctrl_e / bank_ctrl_area;
if (bank_ctrl_pd > factor * data_array_pd)
{
bank_ctrl_area = bank_ctrl_e / (factor * data_array_pd);
}
if (bank_ctrl_area < 0 || bank_ctrl_e * PICOJ < 1)
{
bank_ctrl_area = 0;
bank_ctrl_e = 0;
}
total_area = data_array_area + tag_array_area + decode_area +
data_ctrl_area + tag_ctrl_area + bank_ctrl_area;
// Layout per bank
//
// +------------------------------+
// | bank ctrl |
// +------------------------------+
// | tag | de | data |
// | array | co | array |
// | | de | |
// +------------------------------+
// | tag_ctrl | data_ctrl |
// +------------------------------+
printf ("\nCache bank distributions and energy per access (%d banks)\n",
parameters->NSubbanks);
printf ("\tbank ctrl %5.2g%% %9.3fpJ\n",
100 * bank_ctrl_area / total_area, bank_ctrl_e * PICOJ);
printf ("\tdecode %5.2g%% %9.3fpJ\n", 100 * decode_area / total_area,
decode_e * PICOJ);
printf ("\ttag array %5.2g%% %9.3fpJ\n",
100 * tag_array_area / total_area, tag_array_e * PICOJ);
printf ("\tdata array %5.2g%% %9.3fpJ\n",
100 * data_array_area / total_area, data_array_e * PICOJ);
printf ("\ttag ctrl %5.2g%% %9.3fpJ\n",
100 * tag_ctrl_area / total_area, tag_ctrl_e * PICOJ);
printf ("\tdata ctrl %5.2g%% %9.3fpJ\n",
100 * data_ctrl_area / total_area, data_ctrl_e * PICOJ);
double total_e =
data_array_e + tag_array_e + decode_e + data_ctrl_e + tag_ctrl_e +
bank_ctrl_e;
printf ("\ttotal %9.3fpJ\n", total_e * PICOJ);
xflp->bank_ctrl_a = ar->totalarea * bank_ctrl_area / total_area;
xflp->decode_a = ar->totalarea * decode_area / total_area;
xflp->tag_array_a = ar->totalarea * tag_array_area / total_area;
xflp->data_array_a = ar->totalarea * data_array_area / total_area;
xflp->tag_ctrl_a = ar->totalarea * tag_ctrl_area / total_area;
xflp->data_ctrl_a = ar->totalarea * data_ctrl_area / total_area;
xflp->total_a = xflp->bank_ctrl_a + xflp->decode_a +
xflp->tag_array_a + xflp->data_array_a +
xflp->tag_ctrl_a + xflp->data_ctrl_a;
xflp->bank_ctrl_e = bank_ctrl_e;
xflp->decode_e = decode_e;
xflp->tag_array_e = tag_array_e;
xflp->data_array_e = data_array_e;
xflp->tag_ctrl_e = tag_ctrl_e;
xflp->data_ctrl_e = data_ctrl_e;
xflp->NSubbanks = parameters->NSubbanks;
xflp->assoc = parameters->tag_associativity;
// if (parameters->fully_assoc || parameters->ignore_tag) {
if (parameters->fully_assoc || parameters->force_tag)
{
xflp->assoc = 1;
}
}
int main(int argc, char** argv) {
SkCommandLineFlags::SetUsage(
"Usage: visualize_color_gamut --input <path to input image>"
"--output <path to output image>\n"
"Description: Writes a visualization of the color gamut to the output image\n");
SkCommandLineFlags::Parse(argc, argv);
const char* input = FLAGS_input[0];
const char* output = FLAGS_output[0];
if (!input || !output) {
SkCommandLineFlags::PrintUsage();
return -1;
}
SkAutoTUnref<SkData> data(SkData::NewFromFileName(input));
if (!data) {
SkDebugf("Cannot find input image.\n");
return -1;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
if (!codec) {
SkDebugf("Invalid input image.\n");
return -1;
}
// Load a graph of the CIE XYZ color gamut.
SkBitmap bitmap;
if (!GetResourceAsBitmap("gamut.png", &bitmap)) {
SkDebugf("Program failure.\n");
return -1;
}
SkCanvas canvas(bitmap);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp(codec->getColorSpace());
if (!colorSpace) {
SkDebugf("Image had no embedded color space information. Defaulting to sRGB.\n");
colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
}
// Calculate the points in the gamut from the XYZ values.
SkMatrix44 xyz = colorSpace->xyz();
SkPoint rgb[4];
load_gamut(rgb, xyz);
// Report the XYZ values.
SkDebugf(" X Y Z\n");
SkDebugf("Red %.2f %.2f %.2f\n", xyz.get(0, 0), xyz.get(0, 1), xyz.get(0, 2));
SkDebugf("Green %.2f %.2f %.2f\n", xyz.get(1, 0), xyz.get(1, 1), xyz.get(1, 2));
SkDebugf("Blue %.2f %.2f %.2f\n", xyz.get(2, 0), xyz.get(2, 1), xyz.get(2, 2));
// Report the area of the gamut.
SkDebugf("Area of Gamut: %g\n", calculate_area(rgb));
// Now transform the points so they can be drawn on our canvas. We use 1000 pixels
// to represent the space from 0 to 1. Note that the graph is at an offset of (50, 50).
// Also note that y increases as we move down the canvas.
rgb[0].fX = 50 + 1000*rgb[0].fX;
rgb[0].fY = 50 + 1000*(1 - rgb[0].fY);
rgb[1].fX = 50 + 1000*rgb[1].fX;
rgb[1].fY = 50 + 1000*(1 - rgb[1].fY);
rgb[2].fX = 50 + 1000*rgb[2].fX;
rgb[2].fY = 50 + 1000*(1 - rgb[2].fY);
// Repeat the first point to connect the polygon.
rgb[3] = rgb[0];
SkPaint paint;
canvas.drawPoints(SkCanvas::kPolygon_PointMode, 4, rgb, paint);
// Finally, encode the result to out.png.
SkAutoTUnref<SkData> out(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
if (!out) {
SkDebugf("Failed to encode output.\n");
return -1;
}
SkFILEWStream stream(output);
bool result = stream.write(out->data(), out->size());
if (!result) {
SkDebugf("Failed to write output.\n");
return -1;
}
return 0;
}
int main()
{
#ifdef DEBUG
fp = fopen("test.txt","r");
#endif
int figure = 0;
point* buffer;
int num_of_points;
int i , j;
double area;
buffer = (point*)malloc(sizeof(point) * 1003 );
SCAN("%d",&num_of_points);
while( num_of_points )
{
figure++;
if( figure != 1 )
printf("\n");
for( i = 0 ; i < num_of_points ; i++ )
{
SCAN("%lf %lf" , &buffer[i].x , &buffer[i].y );
}
if( num_of_points < 3 )
{
printf("Figure %d: Impossible\n" , figure );
goto next;
}
buffer[i].x = buffer[0].x;
buffer[i].y = buffer[0].y;
for( i = 0 ; i < num_of_points ; i++ )
{
for( j = i + 2; j < num_of_points ; j++ )
{
if( i == 0 && j == num_of_points - 1 )
continue;
if( is_crossed( buffer , i , j ) )
{
printf("Figure %d: Impossible\n" , figure );
goto next;
}
}
}
area = calculate_area( buffer , num_of_points ) ;
if( area < 0.001 )
printf("Figure %d: Impossible\n" , figure );
else
printf("Figure %d: %.2lf\n" , figure , area );
next:
SCAN( "%d" , &num_of_points );
}
return 0;
}
