void melee_free(scene *scene) {
melee_local *local = scene_get_userdata(scene);
game_player *player2 = game_state_get_player(scene->gs, 1);
surface_free(&local->feh);
surface_free(&local->bleh);
surface_free(&local->select_hilight);
for(int i = 0; i < 2; i++) {
component_free(local->bar_power[i]);
component_free(local->bar_agility[i]);
component_free(local->bar_endurance[i]);
}
for(int i = 0; i < 10; i++) {
object_free(&local->pilots[i]);
object_free(&local->harportraits_player1[i]);
object_free(&local->har_player1[i]);
if (player2->selectable) {
object_free(&local->harportraits_player2[i]);
object_free(&local->har_player2[i]);
}
}
object_free(&local->player2_placeholder);
object_free(&local->unselected_har_portraits);
object_free(&local->bigportrait1);
if (player2->selectable) {
object_free(&local->bigportrait2);
}
free(local);
}
static void textinput_free(component *c) {
textinput *tb = widget_get_obj(c);
surface_free(&tb->sur);
free(tb->text);
free(tb->buf);
free(tb);
}
void textbutton_free(component *c) {
textbutton *tb = c->obj;
if(tb->border_created) {
surface_free(&tb->border);
}
free(tb);
component_free(c);
}
static void textbutton_free(component *c) {
textbutton *tb = widget_get_obj(c);
if(tb->border_created) {
surface_free(&tb->border);
}
free(tb->text);
free(tb);
}
// newsroom callbacks
void newsroom_free(scene *scene) {
newsroom_local *local = scene_get_userdata(scene);
surface_free(&local->news_bg);
str_free(&local->news_str);
str_free(&local->pilot1);
str_free(&local->pilot2);
str_free(&local->har1);
str_free(&local->har2);
dialog_free(&local->continue_dialog);
free(local);
}
void bk_free(bk *b) {
surface_free(&b->background);
vector_free(&b->palettes);
// Free info structs
iterator it;
hashmap_iter_begin(&b->infos, &it);
hashmap_pair *pair = NULL;
while((pair = iter_next(&it)) != NULL) {
bk_info_free((bk_info*)pair->val);
}
hashmap_free(&b->infos);
}
bool_t fb_putcode(struct fb * fb, u32_t code, u32_t fc, u32_t bc, u32_t x, u32_t y)
{
struct surface_t * face;
bool_t ret;
face = surface_alloc_from_gimage(lookup_console_font_face(code, fc, bc));
if(!face)
return FALSE;
ret = fb_blit(fb, face, x, y, face->w, face->h, 0, 0);
surface_free(face);
return ret;
}
void textbutton_set_border(component *c, color col) {
textbutton *tb = c->obj;
tb->border_enabled = 1;
tb->border_color = col;
if(tb->border_created) {
// destroy the old border first
surface_free(&tb->border);
}
// create new border
int chars = strlen(tb->text);
int width = chars*tb->font->w;
menu_background_border_create(&tb->border, width+6, tb->font->h+3);
tb->border_created = 1;
}
void textbutton_set_border(component *c, color col) {
textbutton *tb = widget_get_obj(c);
tb->border_enabled = 1;
tb->border_color = col;
if(tb->border_created) {
// destroy the old border first
surface_free(&tb->border);
}
// create new border
int chars = strlen(tb->text);
int fsize = text_char_width(&tb->tconf);
int width = chars * fsize;
menu_background_border_create(&tb->border, width+6, fsize+3);
tb->border_created = 1;
}
void vs_free(scene *scene) {
vs_local *local = scene_get_userdata(scene);
game_player *player2 = game_state_get_player(scene->gs, 1);
dialog_free(&local->quit_dialog);
dialog_free(&local->too_pathetic_dialog);
surface_free(&local->arena_select_bg);
object_free(&local->player1_portrait);
object_free(&local->player2_portrait);
object_free(&local->player1_har);
object_free(&local->player2_har);
if (player2->selectable) {
object_free(&local->arena_select);
}
free(local);
}
int video_area_capture(surface *sur, int x, int y, int w, int h) {
float scale_x = (float)state.w / NATIVE_W;
float scale_y = (float)state.h / NATIVE_H;
// Correct position (take scaling into account)
SDL_Rect r;
r.x = x * scale_x;
r.y = y * scale_y;
r.w = w * scale_x;
r.h = h * scale_y;
// Create a new surface
surface_create(sur, SURFACE_TYPE_RGBA, r.w, r.h);
// Read pixels
int ret = SDL_RenderReadPixels(state.renderer, &r, SDL_PIXELFORMAT_ABGR8888, sur->data, sur->w * 4);
if(ret != 0) {
surface_free(sur);
PERROR("Unable to read pixels from renderer: %s", SDL_GetError());
return 1;
}
return 0;
}
void kernel_main(uint32_t mb_addr, uint32_t mb_magic)
{
if(mb_magic != MULTIBOOT_BOOTLOADER_MAGIC)
{
kprintf(PANIC,"Wrong Bootloader Magic\n");
for(;;);
}
multiboot_info_t* mb_info = (multiboot_info_t*)mb_addr;
vbe_info_t* vbe_info = (vbe_info_t *)(mb_info->vbe_mode_info);
uint32_t top = mb_info->mem_upper;
uint32_t bot = mb_info->mem_lower;
uint32_t mem = top+bot;
clear_console();
char version[20];
get_version(version);
kp("Welcome to ZOS v%s",version);
kp("System Information");
kp(" Booting Flag: 0x%x",mb_info->flags);
if(check_flag(mb_info->flags,0))
kp(" Available Memory: %d KB / %d MB",mem,mem/1024);
if(check_flag(mb_info->flags,1))
kp(" Booting Device: 0x%x",mb_info->boot_device);
if(check_flag(mb_info->flags,2))
{
if(strlen((char*)mb_info->cmdline)>1)
kp(" Booting Command: %s",(char*)mb_info->cmdline);
}
if(check_flag(mb_info->flags,3))
{}
if(check_flag(mb_info->flags,4))
{}
if(check_flag(mb_info->flags,5))
kernel_elf = elf_from_multiboot(mb_info);
if(check_flag(mb_info->flags,6))
{
/*
multiboot_memory_map_t *mmap;
kp ("mmap_addr = 0x%x, mmap_length = 0x%x",
(unsigned) mb_info->mmap_addr, (unsigned) mb_info->mmap_length);
for (mmap = (multiboot_memory_map_t *) mb_info->mmap_addr;
(unsigned long) mmap < mb_info->mmap_addr + mb_info->mmap_length;
mmap = (multiboot_memory_map_t *) ((unsigned long) mmap
+ mmap->size + sizeof (mmap->size)))
{
kp (" size = 0x%x, base_addr = 0x%x%x,"
" length = 0x%x%x, type = 0x%x",
(unsigned) mmap->size,
mmap->addr >> 32,
mmap->addr & 0xffffffff,
mmap->len >> 32,
mmap->len & 0xffffffff,
(unsigned) mmap->type);
}
*/
}
gdt_init(); /* Global Descriptor Table */
idt_init(); /* Interrupt Descriptor Table */
isrs_init(); /* Interrupt Service Requests */
irq_init(); /* Hardware Interrupt Requests */
open_serial_output();
timer_init();
paging_init(mem);
heap_init();
keyboard_init();
//pci_init();
kp("login: "******"Welcome to ZOS\n",
"Hello!\n",
"abcdefghijklmnopqrstuvwxyz1234567890\n",
0
};
for(int i=0;i!=3;i++)
{
for(int j = 0;j!=strlen(str[i]);j++)
{
gfx_print(str[i][j]);
}
}
void render(window_t* win)
{
}
void update(window_t* win)
{
surface_fill(win->surface,0,rgb(255,255,255));
key_event_t* head;
int len;
keyboard_event_get(&head,&len);
for(int i=0;i!=len;i++)
{
key_event_t* eve = head+i;
if(eve->type == KEY_DOWN)
{
gfx_print(eve->character);
}
}
keyboard_event_clear();
rect_t trect = {0,0,720,20};
for(int i=0;i!=24;i++)
{
if(strlen(gfx_con_buf[i]))
{
surface_t* surf = font_render(gfx_con_buf[i],col);
surface_blend(surf,0,win->surface,&trect);
surface_free(surf);
}
trect.y += 20;
}
}
struct surface_t * map_software_rotate(struct surface_t * surface, struct rect_t * rect, enum rotate_type type)
{
struct surface_t * rotate;
struct rect_t clipped;
u32_t w, h;
if(!surface)
return NULL;
if (!surface->pixels)
return NULL;
if (surface->info.bits_per_pixel < 8)
return NULL;
clipped.x = 0;
clipped.y = 0;
clipped.w = surface->w;
clipped.h = surface->h;
if(rect)
{
if (!rect_intersect(rect, &clipped, &clipped))
return NULL;
}
rect = &clipped;
switch(type)
{
case ROTATE_DEGREE_0:
case ROTATE_DEGREE_180:
case ROTATE_MIRROR_H:
case ROTATE_MIRROR_V:
w = rect->w;
h = rect->h;
break;
case ROTATE_DEGREE_90:
case ROTATE_DEGREE_270:
w = rect->h;
h = rect->w;
break;
default:
return NULL;
}
rotate = surface_alloc(NULL, w, h, surface->info.fmt);
if(!rotate)
return NULL;
switch (surface->info.bytes_per_pixel)
{
case 1:
software_rotate_1byte(rotate, surface, rect, type);
break;
case 2:
software_rotate_2byte(rotate, surface, rect, type);
break;
case 3:
software_rotate_3byte(rotate, surface, rect, type);
break;
case 4:
software_rotate_4byte(rotate, surface, rect, type);
break;
default:
surface_free(rotate);
return NULL;
}
return rotate;
}
void scoreboard_free(scene *scene) {
scoreboard_local *local = scene_get_userdata(scene);
surface_free(&local->black_surface);
free(local);
}
int
geomap(
const size_t ninput, const coord_t* const input,
const size_t nref, const coord_t* const ref,
const bbox_t* const bbox,
const geomap_fit_e fit_geometry,
const surface_type_e function,
const size_t xxorder,
const size_t xyorder,
const size_t yxorder,
const size_t yyorder,
const xterms_e xxterms,
const xterms_e yxterms,
const size_t maxiter,
const double reject,
/* Input/Output */
size_t* const noutput,
/* Output */
geomap_output_t* const output, /* [MAX(ninput, nref)] */
geomap_result_t* const result,
stimage_error_t* const error) {
geomap_fit_t fit;
bbox_t tbbox;
size_t ninput_in_bbox = ninput;
size_t nref_in_bbox = nref;
coord_t* input_in_bbox = NULL;
coord_t* ref_in_bbox = NULL;
double* xfit = NULL;
double* yfit = NULL;
double* weights = NULL;
double* tweights = NULL;
geomap_output_t* outi = NULL;
surface_t sx1, sy1, sx2, sy2;
int has_sx2 = 0;
int has_sy2 = 0;
size_t i = 0;
double my_nan = fmod(1.0, 0.0);
int status = 1;
assert(input);
assert(ref);
assert(error);
if (ninput != nref) {
stimage_error_set_message(
error, "Must have the same number of input and reference coordinates.");
goto exit;
}
surface_new(&sx1);
surface_new(&sy1);
surface_new(&sx2);
surface_new(&sy2);
geomap_fit_init(
&fit, geomap_proj_none, fit_geometry, function,
xxorder, xyorder, xxterms, yxorder, yyorder, yxterms,
maxiter, reject);
/* If bbox is NULL, provide a dummy one full of NaNs */
if (bbox == NULL) {
bbox_init(&tbbox);
} else {
bbox_copy(bbox, &tbbox);
}
/* If the bbox is all NaNs, we don't need to reduce the data, saving an
alloc and copy */
if (bbox == NULL ||
(!isfinite64(tbbox.min.x) && !isfinite64(tbbox.min.y) &&
!isfinite64(tbbox.max.x) && !isfinite64(tbbox.max.y))) {
/* If we have no bbox, we don't need to allocate and copy */
input_in_bbox = (coord_t*)input;
ref_in_bbox = (coord_t*)ref;
ninput_in_bbox = ninput;
nref_in_bbox = nref;
} else {
input_in_bbox = malloc_with_error(
ninput * sizeof(coord_t), error);
if (input_in_bbox == NULL) goto exit;
ref_in_bbox = malloc_with_error(
nref * sizeof(coord_t), error);
if (ref_in_bbox == NULL) goto exit;
/* Reduce data to only those in the bbox */
ninput_in_bbox = nref_in_bbox = limit_to_bbox(
ninput, input, ref, &tbbox, input_in_bbox, ref_in_bbox);
}
/* Compute the mean of the reference and input coordinates */
compute_mean_coord(nref_in_bbox, ref_in_bbox, &fit.oref);
compute_mean_coord(ninput_in_bbox, input_in_bbox, &fit.oin);
/* Set the reference point for the projections to undefined */
fit.refpt.x = my_nan;
fit.refpt.y = my_nan;
/* Allocate some memory */
xfit = malloc_with_error(ninput_in_bbox * sizeof(double), error);
if (xfit == NULL) goto exit;
yfit = malloc_with_error(ninput_in_bbox * sizeof(double), error);
if (yfit == NULL) goto exit;
/* Compute the weights */
weights = malloc_with_error(ninput_in_bbox * sizeof(double), error);
if (weights == NULL) goto exit;
for (i = 0; i < ninput_in_bbox; ++i) {
weights[i] = 1.0;
}
/* Determine the actual max and min of the coordinates */
determine_bbox(nref_in_bbox, ref_in_bbox, &tbbox);
bbox_copy(&tbbox, &fit.bbox);
if (geofit(
&fit, &sx1, &sy1, &sx2, &sy2, &has_sx2, &has_sy2,
ninput_in_bbox, input_in_bbox, ref_in_bbox, weights,
error)) goto exit;
/* Compute the fitted x and y values */
if (geoeval(
&sx1, &sy1, &sx2, &sy2, has_sx2, has_sy2, ninput_in_bbox,
ref_in_bbox, xfit, yfit, error)) goto exit;
if (geo_get_results(
&fit, &sx1, &sy1, &sx2, &sy2, has_sx2, has_sy2, result,
error)) goto exit;
/* DIFF: This section is from geo_plistd */
/* Copy the results to the output buffer */
tweights = malloc_with_error(ninput_in_bbox * sizeof(double), error);
if (tweights == NULL) goto exit;
for (i = 0; i < ninput_in_bbox; ++i) {
tweights[i] = weights[i];
}
for (i = 0; i < fit.nreject; ++i) {
assert(fit.rej);
assert(fit.rej[i] < ninput_in_bbox);
if (weights[fit.rej[i]] > 0.0) {
tweights[fit.rej[i]] = 0.0;
}
}
outi = output;
for (i = 0; i < ninput_in_bbox; ++i, ++outi) {
outi->ref.x = ref_in_bbox[i].x;
outi->ref.y = ref_in_bbox[i].y;
outi->input.x = input_in_bbox[i].x;
outi->input.y = input_in_bbox[i].y;
if (tweights[i] > 0.0) {
outi->fit.x = xfit[i];
outi->fit.y = yfit[i];
outi->residual.x = input_in_bbox[i].x - xfit[i];
outi->residual.y = input_in_bbox[i].y - yfit[i];
} else {
outi->fit.x = my_nan;
outi->fit.y = my_nan;
outi->residual.x = my_nan;
outi->residual.y = my_nan;
}
}
*noutput = ninput_in_bbox;
status = 0;
exit:
if (input_in_bbox != input) {
free(input_in_bbox);
}
if (ref_in_bbox != ref) {
free(ref_in_bbox);
}
free(weights);
free(xfit);
free(yfit);
free(tweights);
surface_free(&sx1);
surface_free(&sy1);
surface_free(&sx2);
surface_free(&sy2);
return status;
}
void menu_free(menu *menu) {
vector_free(&menu->objs);
surface_free(&menu->sur);
}
SDL_Texture* tcache_get(surface *sur,
screen_palette *pal,
char *remap_table,
uint8_t pal_offset) {
if(sur == NULL || sur->w == 0 || sur->h == 0 || sur->data == NULL) {
if(sur != NULL) {
DEBUG("Invalid surface requested from tcache: w,h = %d,%d data = %p", sur->w, sur->h, sur->data);
} else {
DEBUG("Invalid surface requested from tcache: w,h = %d,%d surface = %p", sur->w, sur->h, sur);
}
return NULL;
}
// Form a key
tcache_entry_key key;
memset(&key, 0, sizeof(tcache_entry_key));
key.c_pal_offset = (sur->type == SURFACE_TYPE_RGBA) ? 0 : pal_offset;
key.c_remap_table = (sur->type == SURFACE_TYPE_RGBA) ? 0 : remap_table;
key.c_surface = sur;
key.w = sur->w;
key.h = sur->h;
// Attempt to find appropriate surface
// If surface is cacheable and hasn't changed, just return here.
tcache_entry_value *val = tcache_get_entry(&key);
if(val != NULL && (val->pal_version == pal->version || sur->type == SURFACE_TYPE_RGBA) && !sur->force_refresh) {
val->age = 0;
cache->hits++;
return val->tex;
}
// Reset refresh flag here
sur->force_refresh = 0;
// If there was no fitting surface tex in the cache at all,
// then we need to create one
if(val == NULL) {
tcache_entry_value new_entry;
new_entry.age = 0;
new_entry.pal_version = pal->version;
new_entry.tex = SDL_CreateTexture(cache->renderer,
SDL_PIXELFORMAT_ABGR8888,
SDL_TEXTUREACCESS_STREAMING,
sur->w * cache->scale_factor,
sur->h * cache->scale_factor);
SDL_SetTextureBlendMode(new_entry.tex, SDL_BLENDMODE_BLEND);
val = tcache_add_entry(&key, &new_entry);
}
// We have a texture either from the cache, or we just created one.
// Either one, it needs to be updated. Let's do it now.
// Also, scale surface if necessary
if(cache->scale_factor > 1) {
char *raw = malloc(sur->w * sur->h * 4);
surface scaled;
surface_create(&scaled,
SURFACE_TYPE_RGBA,
sur->w * cache->scale_factor,
sur->h * cache->scale_factor);
surface_to_rgba(sur, raw, pal, remap_table, pal_offset);
scaler_scale(cache->scaler, raw, scaled.data, sur->w, sur->h, cache->scale_factor);
surface_to_texture(&scaled, val->tex, pal, remap_table, pal_offset);
surface_free(&scaled);
free(raw);
} else {
surface_to_texture(sur, val->tex, pal, remap_table, pal_offset);
}
// Set correct age and palette version
val->age = 0;
val->pal_version = pal->version;
// Do some statistics stuff
cache->misses++;
return val->tex;
}
/* DIFF: was gto_fit_rxyscale */
static int
geo_fit_linear(
geomap_fit_t* const fit,
surface_t* const sx1,
surface_t* const sy1,
const size_t ncoord,
const coord_t* const input,
const coord_t* const ref,
const double* const weights,
double* const residual_x,
double* const residual_y,
stimage_error_t* error) {
bbox_t bbox;
double sw = 0.0;
coord_t sr = {0.0, 0.0};
coord_t si = {0.0, 0.0};
coord_t r0 = {0.0, 0.0};
coord_t i0 = {0.0, 0.0};
double sxrxr = 0.0;
double syryr = 0.0;
double syrxi = 0.0;
double sxryi = 0.0;
double sxrxi = 0.0;
double syryi = 0.0;
double num = 0.0;
double denom = 0.0;
double theta = 0.0;
double ctheta = 0.0;
double stheta = 0.0;
coord_t cthetac = {0.0, 0.0};
coord_t sthetac = {0.0, 0.0};
double xmag = 0.0;
double ymag = 0.0;
size_t i = 0;
int status = 1;
assert(fit);
assert(sx1);
assert(sy1);
assert(input);
assert(ref);
assert(weights);
assert(residual_x);
assert(residual_y);
surface_free(sx1);
surface_free(sy1);
bbox_copy(&fit->bbox, &bbox);
bbox_make_nonsingular(&bbox);
/* Compute the sums required to determine the offsets */
compute_sums(ncoord, input, ref, weights, &sw, &si, &sr);
if (sw < 3.0) {
if (fit->projection == geomap_proj_none) {
stimage_error_set_message(
error, "Too few data points for X and Y fits.");
} else {
stimage_error_set_message(
error, "Too few data points for XI and ETA fits.");
}
goto exit;
}
r0.x = sr.x / sw;
r0.y = sr.y / sw;
i0.x = si.x / sw;
i0.y = si.y / sw;
for (i = 0; i < ncoord; ++i) {
sxrxr += weights[i] * (ref[i].x - r0.x) * (ref[i].x - r0.x);
syryr += weights[i] * (ref[i].y - r0.y) * (ref[i].y - r0.y);
syrxi += weights[i] * (ref[i].y - r0.y) * (input[i].x - i0.x);
sxryi += weights[i] * (ref[i].x - r0.x) * (input[i].y - i0.y);
sxrxi += weights[i] * (ref[i].x - r0.x) * (input[i].x - i0.x);
syryi += weights[i] * (ref[i].y - r0.y) * (input[i].y - i0.y);
}
/* Compute the rotation angle */
num = 2.0 * (sxrxr * syrxi * syryi - syryr * sxrxi * sxryi);
denom = syryr * (sxrxi - sxryi) * (sxrxi + sxryi) - \
sxrxr * (syrxi + syryi) * (syrxi - syryi);
if (double_approx_equal(num, 0.0) && double_approx_equal(denom, 0.0)) {
theta = 0.0;
} else {
theta = atan2(num, denom) / 2.0;
if (theta < 0.0) {
theta += M_PI * 2.0;
}
}
ctheta = cos(theta);
stheta = sin(theta);
/* Compute the X magnification factor */
num = sxrxi * ctheta - sxryi * stheta;
denom = sxrxr;
if (denom <= 0.0) {
xmag = 1.0;
} else {
xmag = num / denom;
}
/* Compute the Y magnification factor */
num = syrxi * stheta + syryi * ctheta;
denom = syryr;
if (denom <= 0.0) {
ymag = 1.0;
} else {
ymag = num / denom;
}
/* Compute the polynomial coefficients */
cthetac.x = xmag * ctheta;
sthetac.x = ymag * stheta;
sthetac.y = xmag * stheta;
cthetac.x = ymag * ctheta;
/* Compute the X and Y fit coefficients */
if (compute_surface_coefficients(
fit->function, &bbox, &i0, &r0, &cthetac, &sthetac, sx1, sy1,
error)) goto exit;
/* Compute the residuals */
if (compute_residuals(
sx1, sy1, ncoord, input, ref, residual_x, residual_y,
error)) goto exit;
/* Compute the number of zero-weighted points */
fit->n_zero_weighted = count_zero_weighted(ncoord, weights);
/* Compute the rms of the x and y fits */
compute_rms(
ncoord, weights, residual_x, residual_y, &fit->xrms, &fit->yrms);
fit->ncoord = ncoord;
status = 0;
exit:
return status;
}
/* was geo_fxyd */
static int
geo_fit_xy(
geomap_fit_t* const fit,
surface_t* const sf1,
surface_t* const sf2,
const size_t ncoord,
const int xfit,
const coord_t* const input,
const coord_t* const ref,
/* Output */
int* has_secondary,
double* const weights,
double* const residual,
stimage_error_t* error) {
bbox_t bbox;
double* zfit = NULL;
const double* const z = (double*)input + (xfit ? 0 : 1);
surface_t savefit;
surface_fit_error_e fit_error = surface_fit_error_ok;
size_t i = 0;
int status = 1;
assert(fit);
assert(sf1);
assert(sf2);
assert(ref);
assert(weights);
assert(residual);
assert(has_secondary);
assert(error);
surface_new(&savefit);
surface_free(sf1);
surface_free(sf2);
*has_secondary = 1;
zfit = malloc_with_error(ncoord * sizeof(double), error);
if (zfit == NULL) goto exit;
bbox_copy(&fit->bbox, &bbox);
bbox_make_nonsingular(&bbox);
if (xfit) {
switch(fit->fit_geometry) {
case geomap_fit_shift:
if (surface_init(
&savefit, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
surface_free(sf1);
if (surface_init(
sf1, fit->function, 1, 1, xterms_none, &bbox,
error)) goto exit;
for (i = 0; i < ncoord; ++i) {
zfit[i] = z[i<<1] - ref[i].x;
}
if (surface_fit(
sf1, ncoord, ref, zfit, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->function == surface_type_polynomial) {
savefit.coeff[0] = sf1->coeff[0];
savefit.coeff[1] = 1.0;
savefit.coeff[2] = 0.0;
} else {
savefit.coeff[0] = sf1->coeff[0] + (bbox.max.x + bbox.min.x) / 2.0;
savefit.coeff[1] = (bbox.max.x - bbox.min.x) / 2.0;
savefit.coeff[2] = 0.0;
}
surface_free(sf1);
if (surface_copy(&savefit, sf1, error)) goto exit;
*has_secondary = 0;
break;
case geomap_fit_xyscale:
if (surface_init(
sf1, fit->function, 2, 1, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
*has_secondary = 0;
break;
default:
if (surface_init(
sf1, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->xxorder > 2 || fit->xyorder > 2 ||
fit->xxterms == xterms_full) {
if (surface_init(
sf2, fit->function, fit->xxorder, fit->xyorder,
fit->xxterms, &fit->bbox, error)) {
surface_free(sf1);
goto exit;
}
} else {
*has_secondary = 0;
}
break;
}
} else {
switch(fit->fit_geometry) {
case geomap_fit_shift:
if (surface_init(
&savefit, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
surface_free(sf1);
if (surface_init(
sf1, fit->function, 1, 1, xterms_none, &bbox,
error)) goto exit;
for (i = 0; i < ncoord; ++i) {
zfit[i] = z[i<<1] - ref[i].y;
}
if (surface_fit(
sf1, ncoord, ref, zfit, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->function == surface_type_polynomial) {
savefit.coeff[0] = sf1->coeff[0];
savefit.coeff[1] = 0.0;
savefit.coeff[2] = 1.0;
} else {
savefit.coeff[0] = sf1->coeff[0] + (bbox.min.y + bbox.max.y) / 2.0;
savefit.coeff[1] = 0.0;
savefit.coeff[2] = (bbox.max.y - bbox.min.y) / 2.0;
}
surface_free(sf1);
if (surface_copy(&savefit, sf1, error)) goto exit;
*has_secondary = 0;
break;
case geomap_fit_xyscale:
if (surface_init(
sf1, fit->function, 1, 2, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
*has_secondary = 0;
break;
default:
if (surface_init(
sf1, fit->function, 2, 2, xterms_none, &bbox,
error)) goto exit;
if (surface_fit(
sf1, ncoord, ref, z, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (fit->yxorder > 2 || fit->yyorder > 2 ||
fit->yxterms == xterms_full) {
if (surface_init(
sf2, fit->function, fit->yxorder, fit->yyorder,
fit->yxterms, &bbox, error)) goto exit;
} else {
*has_secondary = 0;
}
break;
}
}
if (_geo_fit_xy_validate_fit_error(
fit_error, xfit, fit->projection, error)) goto exit;
if (surface_vector(sf1, ncoord, ref, residual, error)) goto exit;
for (i = 0; i < ncoord; ++i) {
residual[i] = z[i<<1] - residual[i];
}
/* Calculate the higher-order fit */
if (*has_secondary) {
if (surface_fit(
sf2, ncoord, ref, residual, weights,
surface_fit_weight_user, &fit_error, error)) goto exit;
if (_geo_fit_xy_validate_fit_error(
fit_error, xfit, fit->projection, error)) goto exit;
if (surface_vector(sf2, ncoord, ref, zfit, error)) goto exit;
for (i = 0; i < ncoord; ++i) {
residual[i] = zfit[i] - residual[i];
}
}
/* Compute the number of zero weighted points */
fit->n_zero_weighted = count_zero_weighted(ncoord, weights);
/* Calculate the RMS of the fit */
if (xfit) {
fit->xrms = 0.0;
for (i = 0; i < ncoord; ++i) {
fit->xrms += weights[i] * residual[i] * residual[i];
}
} else {
fit->yrms = 0.0;
for (i = 0; i < ncoord; ++i) {
fit->yrms += weights[i] * residual[i] * residual[i];
}
}
fit->ncoord = ncoord;
status = 0;
exit:
surface_free(&savefit);
free(zfit);
return status;
}
