uint32_t AVDMProcessAudio_Resample::DownKernel(uint8_t * out)
{
int i, j, l;
int32_t xx, yy;
uint32_t done = 0;
iptr += WINSIZ;
while (iptr > eptr)
{
suml = 0;
sumr = 0;
j = -firodrv - sptrr;
for (i = sptr; i <= eptr; i++, j += ISRM)
{
l = j > 0 ? j : -j;
spp = &smpld[i & ((WINSIZ << 1) - 1)];
hgain = hfir[l];
suml += hgain * spp->l;
sumr += hgain * spp->r;
}
#define SAT(x,y) if(x>0.) y=(int32_t)floor(x+0.5); \
else y=(int32_t)floor(x-0.5); \
if(y<(-32768)) y=-32768; else if(y>32768) y=32768;
SAT(suml, xx);
SAT(sumr, yy);
smplo.l = (int16_t) xx;
smplo.r = (int16_t) yy;;
// fwrite(&smplo, sizeof(SmplData), 1, file);
memcpy(out, &smplo, sizeof(SmplData));
out += sizeof(SmplData);
done += sizeof(SmplData);
#define inc(x,y) x += ismd; y += ismr; \
if (y>0) { y -= ISRM; x++; }
// increment sample window
//
inc(sptr, sptrr);
inc(eptr, eptrr);
} // End while
return done;
}
/**
* Show satellite info in a dialog (callback)
*
* @param menuitem The menuitem from where the function is invoked.
* @param data Pointer to parent window or NULL.
*/
void show_sat_info_menu_cb(GtkWidget * menuitem, gpointer data)
{
sat_t *sat;
sat = SAT(g_object_get_data(G_OBJECT(menuitem), "sat"));
show_sat_info(sat, data);
}
/** \brief Manage toggling of Ground Track.
* \param item The menu item that was toggled.
* \param data Pointer to the GtkPolarView structure.
*
*/
static void track_toggled(GtkCheckMenuItem * item, gpointer data)
{
GtkPolarView *pv = GTK_POLAR_VIEW(data);
sat_obj_t *obj = NULL;
sat_t *sat;
/* qth_t *qth; Unused */
gint *catnum;
/* get satellite object */
obj = SAT_OBJ(g_object_get_data(G_OBJECT(item), "obj"));
sat = SAT(g_object_get_data(G_OBJECT(item), "sat"));
/*qth = (qth_t *)(g_object_get_data (G_OBJECT (item), "qth")); */
if (obj == NULL)
{
sat_log_log(SAT_LOG_LEVEL_ERROR,
_("%s:%d: Failed to get satellite object."),
__FILE__, __LINE__);
return;
}
/* toggle flag */
obj->showtrack = !obj->showtrack;
gtk_check_menu_item_set_active(item, obj->showtrack);
catnum = g_new0(gint, 1);
*catnum = sat->tle.catnr;
if (obj->showtrack)
{
/* add sky track */
/* add it to the storage structure */
g_hash_table_insert(pv->showtracks_on, catnum, NULL);
/* remove it from the don't show */
g_hash_table_remove(pv->showtracks_off, catnum);
gtk_polar_view_create_track(pv, obj, sat);
}
else
{
/* add it to the hide */
g_hash_table_insert(pv->showtracks_off, catnum, NULL);
/* remove it from the show */
g_hash_table_remove(pv->showtracks_on, catnum);
/* delete sky track */
gtk_polar_view_delete_track(pv, obj, sat);
}
}
/////////////////////////////////////////////////////////////////////
//Method: IsColliding
//Usage: Asks if there is a collision with another Bounding Object Object
//Arguments:
//MyBOClass* const a_pOther -> Other object to check collision with
//Output: bool -> check of the collision
/////////////////////////////////////////////////////////////////////
bool MyBOClass::IsColliding(MyBOClass* const a_pOther)
{
//Get all vectors in global space
vector3 v3Min = vector3(m_m4ToWorld * vector4(m_v3Min, 1.0f));
vector3 v3Max = vector3(m_m4ToWorld * vector4(m_v3Max, 1.0f));
vector3 v3MinO = vector3(a_pOther->m_m4ToWorld * vector4(a_pOther->m_v3Min, 1.0f));
vector3 v3MaxO = vector3(a_pOther->m_m4ToWorld * vector4(a_pOther->m_v3Max, 1.0f));
/*
Are they colliding?
For Objects we will assume they are colliding, unless at least one of the following conditions is not met
*/
//first check the bounding sphere, if that is not colliding we can guarantee that there are no collision
//if ((m_fRadius + a_pOther->m_fRadius) < glm::distance(m_v3CenterG, a_pOther->m_v3CenterG))
// return false;
//If the distance was smaller it might be colliding
//Do precheck with AABO
bool bColliding = true;
//Check for X
if (m_v3MaxG.x < a_pOther->m_v3MinG.x)
bColliding = false;
if (m_v3MinG.x > a_pOther->m_v3MaxG.x)
bColliding = false;
//Check for Y
if (m_v3MaxG.y < a_pOther->m_v3MinG.y)
bColliding = false;
if (m_v3MinG.y > a_pOther->m_v3MaxG.y)
bColliding = false;
//Check for Z
if (m_v3MaxG.z < a_pOther->m_v3MinG.z)
bColliding = false;
if (m_v3MinG.z > a_pOther->m_v3MaxG.z)
bColliding = false;
if (bColliding == false)
return false;
return SAT(a_pOther);
}
unsigned char *
uyvy_to_rgb24(int width, int height, unsigned char *src, unsigned char *dst) {
unsigned char *s;
unsigned char *d;
const int numpix = width * height;
if (dst == NULL) {
dst = (unsigned char *) malloc(numpix * 3);
}
int l, c;
int r, g, b, cr, cg, cb, y1, y2;
l = height;
s = src;
d = dst;
while (l--) {
c = width >> 1;
while (c--) {
cb = ((*s - 128) * 454) >> 8;
cg = (*s++ - 128) * 88;
y1 = *s++;
cr = ((*s - 128) * 359) >> 8;
cg = (cg + (*s++ - 128) * 183) >> 8;
y2 = *s++;
r = y1 + cr;
b = y1 + cb;
g = y1 - cg;
SAT(r);
SAT(g);
SAT(b);
*d++ = b;
*d++ = g;
*d++ = r;
r = y2 + cr;
b = y2 + cb;
g = y2 - cg;
SAT(r);
SAT(g);
SAT(b);
*d++ = b;
*d++ = g;
*d++ = r;
}
}
return dst;
}
void ccvt_yuyv_bgr32(int width, int height, const void *src, void *dst)
{
const unsigned char *s;
PIXTYPE_bgr32 *d;
int l, c;
int r, g, b, cr, cg, cb, y1, y2;
l = height;
s = src;
d = dst;
while (l--) {
c = width >> 2;
while (c--) {
y1 = *s++;
cb = ((*s - 128) * 454) >> 8;
cg = (*s++ - 128) * 88;
y2 = *s++;
cr = ((*s - 128) * 359) >> 8;
cg = (cg + (*s++ - 128) * 183) >> 8;
r = y1 + cr;
b = y1 + cb;
g = y1 - cg;
SAT(r);
SAT(g);
SAT(b);
d->b = b;
d->g = g;
d->r = r;
d++;
r = y2 + cr;
b = y2 + cb;
g = y2 - cg;
SAT(r);
SAT(g);
SAT(b);
d->b = b;
d->g = g;
d->r = r;
d++;
}
}
}
void CameraEngine::uyvy2rgb(int width, int height, unsigned char *src, unsigned char *dest) {
int R,G,B;
int Y1,Y2;
int cG,cR,cB;
for(int i=height*width/2; i>0; i--) {
cB = ((*src - 128) * 454) >> 8;
cG = (*src++ - 128) * 88;
Y1 = *src++;
cR = ((*src - 128) * 359) >> 8;
cG = (cG + (*src++ - 128) * 183) >> 8;
Y2 = *src++;
R = Y1 + cR;
G = Y1 + cG;
B = Y1 + cB;
SAT(R);
SAT(G);
SAT(B);
*dest++ = B;
*dest++ = G;
*dest++ = R;
R = Y2 + cR;
G = Y2 + cG;
B = Y2 + cB;
SAT(R);
SAT(G);
SAT(B);
*dest++ = B;
*dest++ = G;
*dest++ = R;
}
}
},
{ "-0x.8000000000000002f", 0,
{
SATNEG (-0x4000, -0x40000000, -0x4000000000000001ll),
SATNEG (-0x4000, -0x40000000, -0x4000000000000001ll),
SATNEG (-0x4000, -0x40000000, -0x4000000000000001ll),
SATNEG (-0x4001, -0x40000001, -0x4000000000000002ll)
}
},
/* Strings evaluating very close to 1.0, saturation depending on
rounding mode. */
{ "0x.fffe1", 0,
{
{ UNSAT (0x7fff), UNSAT (0x7fff0800), UNSAT (0x7fff080000000000ll), UNSAT (0xfffe), UNSAT (0xfffe1000u), UNSAT (0xfffe100000000000ull) },
{ UNSAT (0x7fff), UNSAT (0x7fff0800), UNSAT (0x7fff080000000000ll), UNSAT (0xfffe), UNSAT (0xfffe1000u), UNSAT (0xfffe100000000000ull) },
{ SAT (0x7fff), UNSAT (0x7fff0800), UNSAT (0x7fff080000000000ll), UNSAT (0xffff), UNSAT (0xfffe1000u), UNSAT (0xfffe100000000000ull) },
{ UNSAT (0x7fff), UNSAT (0x7fff0800), UNSAT (0x7fff080000000000ll), UNSAT (0xfffe), UNSAT (0xfffe1000u), UNSAT (0xfffe100000000000ull) }
}
},
{ "0x.ffff8", 0,
{
{ SAT (0x7fff), UNSAT (0x7fffc000), UNSAT (0x7fffc00000000000ll), SAT (0xffff), UNSAT (0xffff8000u), UNSAT (0xffff800000000000ull) },
{ UNSAT (0x7fff), UNSAT (0x7fffc000), UNSAT (0x7fffc00000000000ll), UNSAT (0xffff), UNSAT (0xffff8000u), UNSAT (0xffff800000000000ull) },
{ SAT (0x7fff), UNSAT (0x7fffc000), UNSAT (0x7fffc00000000000ll), SAT (0xffff), UNSAT (0xffff8000u), UNSAT (0xffff800000000000ull) },
{ UNSAT (0x7fff), UNSAT (0x7fffc000), UNSAT (0x7fffc00000000000ll), UNSAT (0xffff), UNSAT (0xffff8000u), UNSAT (0xffff800000000000ull) }
}
},
{ "0x.fffffffffffffffff", 0,
{
{ SAT (0x7fff), SAT (0x7fffffff), SAT (0x7fffffffffffffffll), SAT (0xffff), SAT (0xffffffffu), SAT (0xffffffffffffffffull) },
{ UNSAT (0x7fff), UNSAT (0x7fffffff), UNSAT (0x7fffffffffffffffll), UNSAT (0xffff), UNSAT (0xffffffffu), UNSAT (0xffffffffffffffffull) },
mlib_status
mlib_ImageAffineTable_u16nw(
PARAMS_NW)
{
DECLAREVAR;
FP_TYPE buff_local[BUFF_SIZE], *buff = buff_local;
FP_TYPE sat_off = SAT_OFF;
mlib_s32 sbits, x_mask;
mlib_s32 c2_flag = 0, c3_flag = 0;
#ifndef SRC_EXTEND
#if IMG_TYPE == 4
mlib_s32 align = (mlib_s32)lineAddr[0] | ws->srcStride;
c2_flag = ((n & 1) | (m & 3) | (nchan & 1) | (align & 7)) == 0;
c3_flag = (n & 1) == 0 && (m & 1) == 0 && (nchan == 3) && (type == 1);
#endif /* IMG_TYPE == 4 */
#endif /* SRC_EXTEND */
if (type < 4) {
#if IMG_TYPE == 4
b_step = (nchan == 4) ? 2 : nchan;
max_xsize *= b_step;
#ifdef MLIB_USE_FTOI_CLAMPING
sat_off = -127.5;
#else /* MLIB_USE_FTOI_CLAMPING */
sat_off = 0.5;
#endif /* MLIB_USE_FTOI_CLAMPING */
#endif /* IMG_TYPE == 4 */
if (max_xsize > BUFF_SIZE) {
buff = __mlib_malloc(max_xsize * sizeof (FP_TYPE));
if (buff == NULL)
return (MLIB_FAILURE);
}
}
#if FLT_BITS == 2
filterX = table->dataH_f32;
filterY = table->dataV_f32;
#else /* FLT_BITS == 2 */
filterX = table->dataH_d64;
filterY = table->dataV_d64;
#endif /* FLT_BITS == 2 */
DIST_BITS();
#ifndef SRC_EXTEND
switch (nchan) {
case 1:
sbits = 0;
break;
case 2:
sbits = 1;
break;
case 3:
sbits = 0;
break;
case 4:
sbits = 2;
break;
default:
sbits = 0;
break;
}
#else /* SRC_EXTEND */
sbits = 0;
#endif /* SRC_EXTEND */
x_mask = ~((1 << sbits) - 1);
x_shift -= sbits;
ws->x_shift = x_shift;
ws->x_mask = x_mask;
ws->xf_shift = xf_shift;
ws->xf_mask = xf_mask;
ws->yf_shift = yf_shift;
ws->yf_mask = yf_mask;
for (j = yStart; j <= yFinish; j++) {
old_size = size;
CLIP(CHAN1);
if (type < 4) {
#if IMG_TYPE == 4
/*
* u8 via F32 image
*/
if (c2_flag || c3_flag)
b_step = (nchan == 4) ? 2 : nchan;
else
b_step = 1;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = b_step * old_size; i < b_step * size; i++) {
buff[i] = sat_off;
}
#else /* IMG_TYPE == 4 */
/*
* process by one channel
*/
b_step = 1;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = old_size; i < size; i++) {
buff[i] = sat_off;
}
#endif /* IMG_TYPE == 4 */
} else {
/* mlib_f32 types */
b_step = nchan;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < size * nchan; i++) {
dstPixelPtr[i] = (DTYPE) sat_off;
}
}
ws->b_step = b_step;
/*
* move to kernel center
*/
x0 -= ws->x_move;
y0 -= ws->y_move;
ws->size = size;
ws->x0 = x0;
ws->y0 = y0;
for (k = 0; k < nchan; k++) {
#if IMG_TYPE < 4
DTYPE *dPtr = dstPixelPtr + k;
#endif /* IMG_TYPE < 4 */
if (c2_flag && (k & 1))
continue;
if (c3_flag && k)
continue;
ws->k = k;
if (type >= 4) {
buff = (void *)(dstPixelPtr + k);
}
for (l = 0; l < n; l += kh) {
/* kernel lines */
kh = n - l;
if (kh >= 4 && (m & 3) == 0 &&
!(c2_flag | c3_flag))
kh = 4;
else if (kh >= 2)
kh = 2;
for (off = 0; off < m; off += kw) {
/* offset in current kernel line */
ws->x0 = x0 + (off << (x_shift +
sbits));
kw = m - off;
if (kw > 2 * MAX_KER)
kw = MAX_KER;
else if (kw > MAX_KER)
kw = kw / 2;
#ifndef SRC_EXTEND
#if IMG_TYPE == 4
if (c3_flag) {
kw = 2;
FUNCNAME(c3_2_2)
(buff, filterX + off,
filterY + l,
lineAddr + l, ws);
continue;
}
if (c2_flag) {
if (nchan == 2) {
FUNCNAME(c2_2_4)
(buff,
filterX + off,
filterY + l,
lineAddr + l,
ws);
} else {
FUNCNAME(c4_2_4)
(buff,
filterX + off,
filterY + l,
lineAddr + l,
ws);
}
} else
#endif /* IMG_TYPE == 4 */
#endif /* SRC_EXTEND */
CALL_FUNC(u16);
}
}
#if IMG_TYPE < 4
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < size; i++) {
FP_TYPE val = buff[i] >> (SHIFT+SHIFT);
#if IMG_TYPE < 3 && defined(MLIB_USE_FTOI_CLAMPING)
mlib_s32 ival;
#endif /* IMG_TYPE < 3 && defined(MLIB_USE_FTOI_CLAMPING) */
SAT(dPtr[i * nchan], ival, val);
buff[i] = sat_off;
}
#endif /* IMG_TYPE < 4 */
#if IMG_TYPE == 4
if (type == 1) {
mlib_u8 *dp =
(mlib_u8 *)dstData + nchan * xLeft + k;
if (c3_flag) {
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < 3 * size; i++) {
FP_TYPE val = (FP_TYPE) buff[i];
#ifdef MLIB_USE_FTOI_CLAMPING
mlib_s32 ival;
#endif /* MLIB_USE_FTOI_CLAMPING */
SAT8(dp[i], ival, val);
buff[i] = sat_off;
}
} else if (c2_flag) {
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < size; i++) {
FP_TYPE val0 =
(FP_TYPE) buff[2 * i];
FP_TYPE val1 =
(FP_TYPE) buff[2 * i +
1];
#ifdef MLIB_USE_FTOI_CLAMPING
mlib_s32 ival0, ival1;
#endif /* MLIB_USE_FTOI_CLAMPING */
SAT8(dp[i * nchan], ival0,
val0);
SAT8(dp[i * nchan + 1], ival1,
val1);
buff[2 * i] = sat_off;
buff[2 * i + 1] = sat_off;
}
} else {
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < size; i++) {
FP_TYPE val = (FP_TYPE) buff[i];
#ifdef MLIB_USE_FTOI_CLAMPING
mlib_s32 ival;
#endif /* MLIB_USE_FTOI_CLAMPING */
SAT8(dp[i * nchan], ival, val);
buff[i] = sat_off;
}
}
}
#endif /* IMG_TYPE == 4 */
}
}
if (type < 4) {
if (buff != buff_local)
__mlib_free(buff);
}
return (MLIB_SUCCESS);
}
/** \brief Create and run GtkSatModule popup menu.
* \param module The module that should have the popup menu attached to it.
*
* This function ctreates and executes a popup menu that is related to a
* GtkSatModule widget. The module must be a valid GtkSatModule, since it makes
* no sense whatsoever to have this kind of popup menu without a GtkSatModule
* parent.
*
*/
void gtk_sat_module_popup (GtkSatModule *module)
{
GtkWidget *menu; /* The pop-up menu */
GtkWidget *satsubmenu; /* Satellite selection submenu */
GtkWidget *menuitem; /* Widget used to create the menu items */
GtkWidget *image; /* Widget used to create menu item icons */
/* misc variables */
GList *sats;
sat_t *sat;
gchar *buff;
guint i,n;
if ((module == NULL) || !IS_GTK_SAT_MODULE (module)) {
sat_log_log (SAT_LOG_LEVEL_ERROR,
_("%s:%d: %s called with NULL parameter!"),
__FILE__, __LINE__, __FUNCTION__);
return;
}
menu = gtk_menu_new ();
if (module->state == GTK_SAT_MOD_STATE_DOCKED) {
menuitem = gtk_image_menu_item_new_with_label (_("Detach module"));
buff = icon_file_name ("gpredict-notebook.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (docking_state_cb), module);
}
else {
menuitem = gtk_image_menu_item_new_with_label (_("Attach module"));
buff = icon_file_name ("gpredict-notebook.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (docking_state_cb), module);
}
if (module->state == GTK_SAT_MOD_STATE_FULLSCREEN) {
menuitem = gtk_image_menu_item_new_with_label (_("Exit full screen"));
image = gtk_image_new_from_stock (GTK_STOCK_LEAVE_FULLSCREEN,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (screen_state_cb), module);
}
else {
menuitem = gtk_image_menu_item_new_with_label (_("Full screen"));
image = gtk_image_new_from_stock (GTK_STOCK_FULLSCREEN,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (screen_state_cb), module);
}
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* select satellite submenu */
menuitem = gtk_menu_item_new_with_label(_("Select satellite"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
satsubmenu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), satsubmenu);
sats = g_hash_table_get_values(module->satellites);
sats = g_list_sort(sats , (GCompareFunc) sat_nickname_compare );
n = g_list_length(sats);
for (i = 0; i < n; i++) {
sat = SAT(g_list_nth_data(sats, i));
menuitem = gtk_menu_item_new_with_label(sat->nickname);
g_object_set_data(G_OBJECT(menuitem), "catnum", GINT_TO_POINTER(sat->tle.catnr));
g_signal_connect(menuitem, "activate", G_CALLBACK (sat_selected_cb), module);
gtk_menu_shell_append(GTK_MENU_SHELL(satsubmenu), menuitem);
}
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* sky at a glance */
menuitem = gtk_image_menu_item_new_with_label (_("Sky at a glance"));
buff = icon_file_name ("gpredict-planner-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (sky_at_glance_cb), module);
/* time manager */
menuitem = gtk_image_menu_item_new_with_label (_("Time Controller"));
buff = icon_file_name ("gpredict-clock-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate", G_CALLBACK (tmgr_cb), module);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* Radio Control */
menuitem = gtk_image_menu_item_new_with_label (_("Radio Control"));
buff = icon_file_name ("gpredict-oscilloscope-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate", G_CALLBACK (rigctrl_cb), module);
/* Antenna Control */
menuitem = gtk_image_menu_item_new_with_label (_("Antenna Control"));
buff = icon_file_name ("gpredict-antenna-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate", G_CALLBACK (rotctrl_cb), module);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* configure */
menuitem = gtk_image_menu_item_new_with_label (_("Configure"));
image = gtk_image_new_from_stock (GTK_STOCK_PROPERTIES,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (config_cb), module);
/* clone */
menuitem = gtk_image_menu_item_new_with_label (_("Clone..."));
image = gtk_image_new_from_stock (GTK_STOCK_COPY,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (clone_cb), module);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* delete module */
menuitem = gtk_image_menu_item_new_with_label (_("Delete"));
image = gtk_image_new_from_stock (GTK_STOCK_DELETE,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (delete_cb), module);
/* close */
menuitem = gtk_image_menu_item_new_with_label (_("Close"));
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (close_cb), module);
gtk_widget_show_all (menu);
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
0, gdk_event_get_time (NULL));
}
bool Formula::SAT(Assignment* a)
{
if (numberOfClauses == 0)
return false;
bool* localAssigns = new bool[varRange + 1];
for (int i = 0; i <= varRange; i++)
{
localAssigns[i] = false;
}
if (a == nullptr)
a = new Assignment(varRange);
Bool val = getValue(a);
if (val == 1)
return true;
else if (val == -1)
return false;
for (int i = 0; i < clauses.size(); i++)
{
if (clauses[i]->unassignedLiterals(a) == 1)
{
int lit = clauses[i]->unassignedLiteral(a);
localAssigns[abs(lit)] = true;
a->setValue(abs(lit), lit > 0 ? 1 : -1);
}
}
for (int i = 1; i <= varRange; i++)
{
if (a->getValue(i) == 0)
{
Bool hasVar = 0;
for (int j = 0; j < clauses.size(); j++)
{
if (clauses[j]->getValue(a) != 0)
continue;
Bool clauseHasVar = clauses[j]->hasVar(i);
if (hasVar == 0)
hasVar = clauseHasVar;
else if (hasVar != clauseHasVar)
{
hasVar = 0;
break;
}
}
if (hasVar != 0)
{
a->setValue(i, hasVar == 1);
localAssigns[i] = true;
}
}
}
int chosenLit = varRange;
while (chosenLit != 0 && a->getValue(chosenLit) != 0)
chosenLit--;
bool result;
if (chosenLit == 0)
{
result = getValue(a) == 1;
}
else
{
a->setValue(chosenLit, 1);
result = SAT(a);
if (result)
return result;
a->setValue(chosenLit, -1);
result = SAT(a);
if (result)
return result;
}
a->unsetValue(chosenLit);
for (int i = 1; i <= varRange; i++)
{
if (localAssigns[i])
a->unsetValue(i);
}
return result;
}
static void
show_next_pass_cb (GtkWidget *menuitem, gpointer data)
{
GtkPolarView *pv = GTK_POLAR_VIEW (data);
sat_t *sat;
qth_t *qth;
pass_t *pass;
GtkWidget *dialog;
GtkWindow *toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (data)));
/* get next pass */
sat = SAT(g_object_get_data (G_OBJECT (menuitem), "sat"));
qth = (qth_t *) (g_object_get_data (G_OBJECT (menuitem), "qth"));
/* check wheather sat actially has AOS */
if ((sat->otype != ORBIT_TYPE_GEO) && (sat->otype != ORBIT_TYPE_DECAYED) &&
has_aos (sat, qth)) {
if (sat_cfg_get_bool(SAT_CFG_BOOL_PRED_USE_REAL_T0)) {
pass = get_next_pass (sat, qth,
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD));
}
else {
pass = get_pass (sat, qth, pv->tstamp,
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD));
}
if (pass != NULL) {
show_pass (sat->nickname, qth, pass, GTK_WIDGET (toplevel));
}
else {
/* show dialog that there are no passes within time frame */
dialog = gtk_message_dialog_new (toplevel,
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
_("Satellite %s has no passes\n"\
"within the next %d days"),
sat->nickname,
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
}
else {
/* show dialog telling that this sat never reaches AOS*/
dialog = gtk_message_dialog_new (toplevel,
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Satellite %s has no passes for\n"\
"the current ground station!\n\n"\
"This can be because the satellite\n"\
"is geostationary, decayed or simply\n"\
"never comes above the horizon"),
sat->nickname);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
}
/** \brief Manage toggling of Ground Track.
* \param item The menu item that was toggled.
* \param data Pointer to the GtkPolarView structure.
*
*/
static void
track_toggled (GtkCheckMenuItem *item, gpointer data)
{
GtkPolarView *pv = GTK_POLAR_VIEW (data);
sat_obj_t *obj = NULL;
sat_t *sat;
qth_t *qth;
gint idx,i;
GooCanvasItemModel *root;
pass_detail_t *detail;
guint num;
GooCanvasPoints *points;
gfloat x,y;
guint32 col;
guint tres,ttidx;
/* get satellite object */
obj = SAT_OBJ(g_object_get_data (G_OBJECT (item), "obj"));
sat = SAT(g_object_get_data (G_OBJECT (item), "sat"));
qth = (qth_t *)(g_object_get_data (G_OBJECT (item), "qth"));
if (obj == NULL) {
sat_log_log (SAT_LOG_LEVEL_BUG,
_("%s:%d: Failed to get satellite object."),
__FILE__, __LINE__);
return;
}
/* toggle flag */
obj->showtrack = !obj->showtrack;
gtk_check_menu_item_set_active (item, obj->showtrack);
root = goo_canvas_get_root_item_model (GOO_CANVAS (pv->canvas));
if (obj->showtrack) {
/* add sky track */
/* create points */
num = g_slist_length (obj->pass->details);
if (num == 0) {
sat_log_log (SAT_LOG_LEVEL_BUG,
_("%s:%d: Pass has no details."),
__FILE__, __LINE__);
return;
}
/* time resolution for time ticks; we need
3 additional points to AOS and LOS ticks.
*/
tres = (num-2) / (TRACK_TICK_NUM-1);
points = goo_canvas_points_new (num);
/* first point should be (aos_az,0.0) */
azel_to_xy (pv, obj->pass->aos_az, 0.0, &x, &y);
points->coords[0] = (double) x;
points->coords[1] = (double) y;
obj->trtick[0] = create_time_tick (pv, obj->pass->aos, x, y);
ttidx = 1;
for (i = 1; i < num-1; i++) {
detail = PASS_DETAIL(g_slist_nth_data (obj->pass->details, i));
if (detail->el >=0.0)
azel_to_xy (pv, detail->az, detail->el, &x, &y);
points->coords[2*i] = (double) x;
points->coords[2*i+1] = (double) y;
if (!(i % tres)) {
/* create a time tick */
if (ttidx<TRACK_TICK_NUM)
obj->trtick[ttidx] = create_time_tick (pv, detail->time, x, y);
ttidx++;
}
}
/* last point should be (los_az, 0.0) */
azel_to_xy (pv, obj->pass->los_az, 0.0, &x, &y);
points->coords[2*(num-1)] = (double) x;
points->coords[2*(num-1)+1] = (double) y;
/* create poly-line */
col = mod_cfg_get_int (pv->cfgdata,
MOD_CFG_POLAR_SECTION,
MOD_CFG_POLAR_TRACK_COL,
SAT_CFG_INT_POLAR_TRACK_COL);
obj->track = goo_canvas_polyline_model_new (root, FALSE, 0,
"points", points,
"line-width", 1.0,
"stroke-color-rgba", col,
"line-cap", CAIRO_LINE_CAP_SQUARE,
"line-join", CAIRO_LINE_JOIN_MITER,
NULL);
goo_canvas_points_unref (points);
/* put track on the bottom of the sack */
goo_canvas_item_model_lower (obj->track, NULL);
}
else {
/* delete sky track */
idx = goo_canvas_item_model_find_child (root, obj->track);
if (idx != -1) {
goo_canvas_item_model_remove_child (root, idx);
}
for (i = 0; i < TRACK_TICK_NUM; i++) {
idx = goo_canvas_item_model_find_child (root, obj->trtick[i]);
if (idx != -1) {
goo_canvas_item_model_remove_child (root, idx);
}
}
}
}
gmu_bufgranul(t_symbol * sym, long ac, t_atom * av)
{
int symcount = 0;
float f;
bool gotnum=false;
t_symbol * bufsym = NULL;
t_symbol * envsym = NULL;
t_symbol * spatsym = NULL;
t_atom def_env[5];
// initialisation param
nspeakers = 2;
nvoices_active = 0;
active_env = 0;
conf.sinterp = 1;
conf.loop = false;
conf.sr = sys_getsr();
begin = 0.;
transp = 1.;
amp = 1.;
length = 100.;
position.x = 0.;
position.y = 0.;
position.z = 0.;
// initialisation interp table
linear_interp_table = (t_linear_interp *) sysmem_newptr( TABLE_SIZE * sizeof(struct linear_interp) );
for(int i=0; i<TABLE_SIZE ; i++)
{
f = (float)(i)/TABLE_SIZE; // va de 0 a 1
linear_interp_table[i].a = 1 - f;
linear_interp_table[i].b = f;
}
gmu_bufgrain::interp_table = linear_interp_table;
gmu_env::interp_table = linear_interp_table;
// objects parameters
for (int j=0; j < ac; j++){
switch (av[j].a_type){
case A_LONG: // num speakers
nspeakers= SAT(av[j].a_w.w_long,1,MAX_NUM_SPEAKERS);
gotnum = true;
post("bufgranul~ : nouts %d",nspeakers);
break;
case A_SYM:
if(gotnum) // spat type
{
spatsym = av[j].a_w.w_sym;
post("bufgranul~ : spat %s",spatsym->s_name);
}
else
if(symcount==1) // env buffer // TODO: make possible choice of algos
{
envsym = av[j].a_w.w_sym;
symcount++;
post("bufgranul~ : env %s",envsym->s_name);
}else // buffer
{
bufsym = av[j].a_w.w_sym;
symcount++;
post("bufgranul~ : sound %s",bufsym->s_name);
}
break;
case A_FLOAT:
post("argument %ld is a float : %lf, not assigned", (long)j,av[j].a_w.w_float);
break;
}
}
// DSP init
setupIO(&gmu_bufgranul::perform, 0, nspeakers);
// SPAT ASSIGN
if(spatsym)
{
if(!strcmp(spatsym->s_name,"dbap"))
spat_class = new gmu_spat_dbap(nspeakers);
else
spat_class = new gmu_spat_dbap(nspeakers);
}
else
spat_class = new gmu_spat_dbap(nspeakers);
// ENV BUFFER MANAGER
env_shrbuf_manager = new gmu_env_shrbuf_manager();
// ENV ASSIGN
int env_p_n;
if(envsym)
{
atom_setsym(def_env, gensym("buffer"));
atom_setsym(def_env+1, envsym);
env_p_n = 2;
}
else
{
atom_setsym(def_env, gensym("trap"));
env_p_n = 1;
}
t_symbol * param;
param = atom_getsym(def_env);
for(int i = 0; i < MAX_ENV_SLOTS ; i++ )
env_slots[i] = new gmu_env_slot(env_shrbuf_manager,env_p_n,def_env);
// BUFFER ASSIGN
if(bufsym != NULL)
{
default_buffer = new gmu_buffer(&conf,bufsym);
if(default_buffer->is_valid)
{
buffer_slots[0] = default_buffer;
buffer_pool[string(bufsym->s_name)] = default_buffer;
gmu_buffer::valid_buffer = default_buffer;
}
else
error("bufgranul~ : default sound buffer is not valid");
}
// TEMP BUFFER ALLOC for GRAINS
gmu_bufgrain::tmp_buffer = (float *) sysmem_newptr(8192 * sizeof(float));
// critical
//critical_new(critical);
}
int main(int argc, char **argv){
if(argc != 9){
printf("wrong # args\n");
printf("inputfile outDir(./lol/) invert (0 or 1) k*1000 windowRadius gaussPyramidThresh(>= survive) finalMixThresh(>= survive) writeDebugImages(0 or 1)\n");
}
int width, height, channels;
unsigned char *data;
char *dir = argv[2];
int inv = atoi(argv[3]);
float k = float(atoi(argv[4]))/1000.f;
int window = atoi(argv[5]);
int gaussPyramidThresh = atoi(argv[6]);
int finalMixThresh = atoi(argv[7]);
bool debugImages = atoi(argv[8]);
bool res = loadImage(argv[1], &width, &height, &channels, &data);
if(!res){
printf("error reading image\n");
return 1;
}
printf("start\n");
// to grayscale
unsigned char *dataGray = new unsigned char[width*height];
toGrayscale(width,height,data,dataGray);
// build SAT
unsigned int *sat = new unsigned int[width*height];
float * satSquared = new float[width*height];
SAT(dataGray,sat,width,height);
SATSquared(dataGray,satSquared,width,height);
// do thresh
thresh(dataGray, sat, satSquared, width, height, k, window);
if(inv){invert(dataGray,width,height);}
char filename[200];
sprintf(filename,"%sresRaw.bmp",dir);
if(debugImages){saveImage(filename, width, height, 1, dataGray);}
unsigned char ** pyramid=NULL;
makePyramid(dataGray, &pyramid, pyramidLevels, gaussPyramidThresh, width,height);
for(int L=0; L<pyramidLevels; L++){
char filename[200];
sprintf(filename,"%sres_raw_%d.bmp",dir,L);
if(debugImages){saveImage(filename,width/pow(2,L),height/pow(2,L),1,pyramid[L]);}
}
// label
int vecSizeY=32;
int vecSizeX=128;
unsigned char *dist=new unsigned char[width*height];
unsigned short *labels = new unsigned short[width*height];
unsigned short area[maxLabels];
unsigned char *reason = new unsigned char[width*height];
unsigned char *tile = new unsigned char[width*height];
for(int l = pyramidLevels-1; l>=0; l--){
int lw = width/pow(2,l);
int lh = height/pow(2,l);
// write out debug data
char filename[200];
sprintf(filename,"%sres_%dp2.bmp",dir,l);
if(debugImages){saveImage(filename, lw,lh, 1, pyramid[l]);}
}
for(int L = pyramidLevels-1; L>=0; L--){
int lw = width/pow(2,L);
int lh = height/pow(2,L);
// clear out labels so that we can do progressive cleanup passes
for(int i=0; i<lw*lh; i++){reason[i]=0;labels[i]=0;}
unsigned short firstId = 1;
int tileId = 0;
int minArea = 6;
if(L<2){minArea = 30;}
int nTilesX = ceil((float)lw/(float)vecSizeX);
int nTilesY = ceil((float)lh/(float)vecSizeY);
int lastFixup = 0;
for(int by=0; by<nTilesY; by++){
int endY = (by+1)*vecSizeY;
if(endY>lh){endY=lh;}
bool fixupRanThisRow = false;
for(int bx=0; bx<nTilesX; bx++){
int endX = (bx+1)*vecSizeX;
if(endX>lw){endX=lw;}
label(pyramid[L],labels,reason,area,lw,lh,minArea,vecSizeX*bx,endX,vecSizeY*by,endY,maxLabels);
unsigned short lastId=0;
if(!condenseLabels(labels,area,firstId,&lastId,lw,lh,vecSizeX*bx,endX,vecSizeY*by,endY,maxLabels)){
printf("Error: ran out of labels!\n");
goto writeout; // an exception occured
}
firstId=lastId+1;
//printf("ML %d\n",(int)firstId);
// for debugging
for(int x=vecSizeX*bx; x<endX; x++){
for(int y=vecSizeY*by; y<endY; y++){
tile[x+y*lw]=tileId;
}
}
tileId++;
if(firstId > (maxLabels*4)/5 && !fixupRanThisRow){
labelProp(labels,area,lw,lh,0,lw,0,endY,maxLabels);
filter(pyramid,L,reason,labels,minArea,lw,lh,width,0,lw,lastFixup,endY,maxLabels);
computeArea(labels,area,lw,lh,0,lw,0,endY,maxLabels);
condenseLabels(labels,area,1,&firstId,lw,lh,0,lw,0,endY,maxLabels);
firstId++;
printf("fixup TL %d\n",firstId);
lastFixup = (by+1)*vecSizeY;
fixupRanThisRow=true;
}
}
}
// fix labels across region boundries
labelProp(labels,area,lw,lh,0,lw,0,lh,maxLabels);
computeArea(labels,area,lw,lh,0,lw,0,lh,maxLabels);
condenseLabels(labels,area,1,&firstId,lw,lh,0,lw,0,lh,maxLabels);
//printf("TL %d\n",firstId);
distanceTransform(pyramid[L],dist,0,lw,lh);
filter(pyramid,L,reason,labels,minArea,lw,lh,width,0,lw,0,lh,maxLabels);
// now what's left "must" be text, so delete it from other pyrmid levels and save it
writeout:
// write out debug data
char filename[200];
if(debugImages){
sprintf(filename,"%sL_%d.bmp",dir,L);
saveImage(filename, lw,lh, labels);
sprintf(filename,"%sD_%d.bmp",dir,L);
saveImage(filename, lw,lh, 1, dist);
sprintf(filename,"%sres_%d.bmp",dir,L);
saveImage(filename, lw,lh, 1, pyramid[L]);
sprintf(filename,"%sR_%d.bmp",dir,L);
saveImage(filename, lw,lh, 1, reason);
sprintf(filename,"%sT_%d.bmp",dir,L);
saveImage(filename, lw,lh, 1, tile);
}
if(L==pyramidLevels-1){
for(int l = 2; l>=0; l--){
int lw = width/pow(2,l);
int lh = height/pow(2,l);
// write out debug data
char filename[200];
sprintf(filename,"%sres_%dp.bmp",dir,l);
if(debugImages){saveImage(filename, lw,lh, 1, pyramid[l]);}
}
}
}
for(int y=0; y<height; y++){
for(int x=0; x<width; x++){
int count=0;
for(int l=0; l<pyramidLevels; l++){
int lx = x/pow(2,l);
int ly = y/pow(2,l);
int lw = width/pow(2,l);
if(pyramid[l][lx+ly*lw]){count++;}
}
if(count<finalMixThresh){
dataGray[x+y*width]=0;
}
}
}
sprintf(filename,"%sres.bmp",dir);
saveImage(filename, width, height, 1, dataGray);
return 0;
}
static void show_future_passes_cb (GtkWidget *menuitem, gpointer data)
{
GtkWidget *dialog;
GtkWindow *toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (data)));
GtkEventList *list = GTK_EVENT_LIST (data);
GSList *passes = NULL;
sat_t *sat;
qth_t *qth;
sat = SAT(g_object_get_data (G_OBJECT (menuitem), "sat"));
qth = (qth_t *) (g_object_get_data (G_OBJECT (menuitem), "qth"));
/* check wheather sat actially has AOS */
if ((sat->otype != ORBIT_TYPE_GEO) && (sat->otype != ORBIT_TYPE_DECAYED) &&
has_aos (sat, qth)) {
if (sat_cfg_get_bool (SAT_CFG_BOOL_PRED_USE_REAL_T0)) {
passes = get_next_passes (sat, qth,
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD),
sat_cfg_get_int (SAT_CFG_INT_PRED_NUM_PASS));
}
else {
passes = get_passes (sat, qth, list->tstamp,
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD),
sat_cfg_get_int (SAT_CFG_INT_PRED_NUM_PASS));
}
if (passes != NULL) {
show_passes (sat->nickname, qth, passes, GTK_WIDGET (toplevel));
}
else {
/* show dialog that there are no passes within time frame */
dialog = gtk_message_dialog_new (toplevel,
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
_("Satellite %s has no passes\n"\
"within the next %d days"),
sat->nickname,
sat_cfg_get_int (SAT_CFG_INT_PRED_LOOK_AHEAD));
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
}
else {
/* show dialog */
GtkWidget *dialog;
dialog = gtk_message_dialog_new (toplevel,
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Satellite %s has no passes for\n"\
"the current ground station!"),
sat->nickname);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
}
}
void CameraEngine::yuyv2rgb(int width, int height, unsigned char *src, unsigned char *dest) {
int R,G,B;
int Y1,Y2;
int U,V;
for(int y=0;y<height;y++) {
for(int x=0;x<width/2;x++) {
Y1 = *src++;
U = *src++ -128;
Y2 = *src++;
V = *src++ -128;
R = (int)(Y1 + 1.370705f * V);
G = (int)(Y1 - 0.698001f * V - 0.337633f * U);
B = (int)(Y1 + 1.732446f * U);
SAT(R);
SAT(G);
SAT(B);
*dest++ = B;
*dest++ = G;
*dest++ = R;
R = (int)(Y2 + 1.370705f * V);
G = (int)(Y2 - 0.698001f * V - 0.337633f * U);
B = (int)(Y2 + 1.732446f * U);
SAT(R);
SAT(G);
SAT(B);
*dest++ = B;
*dest++ = G;
*dest++ = R;
}
}
/*int R,G,B;
int Y1,Y2;
int cG,cR,cB;
for(int i=height*width/2;i>0;i--) {
cB = ((*src - 128) * 454) >> 8;
cG = (*src++ - 128) * 88;
Y1 = *src++;
cR = ((*src - 128) * 359) >> 8;
cG = (cG + (*src++ - 128) * 183) >> 8;
Y2 = *src++;
R = Y1 + cR;
G = Y1 + cG;
B = Y1 + cB;
SAT(R);
SAT(G);
SAT(B);
*dest++ = B;
*dest++ = G;
*dest++ = R;
R = Y2 + cR;
G = Y2 + cG;
B = Y2 + cB;
SAT(R);
SAT(G);
SAT(B);
*dest++ = B;
*dest++ = G;
*dest++ = R;
}*/
}
mlib_status
mlib_ImageAffineTable_8_3nw(
PARAMS_NW)
{
DECLAREVAR;
FP_TYPE buff_local[BUFF_SIZE], *buff = buff_local;
FP_TYPE sat_off = SAT_OFF;
if (type < 4) {
if (max_xsize > BUFF_SIZE) {
buff = __mlib_malloc(max_xsize * sizeof (FP_TYPE));
if (buff == NULL)
return (MLIB_FAILURE);
}
}
#if FLT_BITS == 2
filterX = table->dataH_f32;
filterY = table->dataV_f32;
#else /* FLT_BITS == 2 */
filterX = table->dataH_d64;
filterY = table->dataV_d64;
#endif /* FLT_BITS == 2 */
DIST_BITS();
ws->x_shift = x_shift;
ws->xf_shift = xf_shift;
ws->xf_mask = xf_mask;
ws->yf_shift = yf_shift;
ws->yf_mask = yf_mask;
for (j = yStart; j <= yFinish; j++) {
old_size = size;
CLIP(CHAN1);
if (type < 4) {
/*
* process by one channel
*/
b_step = 1;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = old_size; i < size; i++) {
buff[i] = sat_off;
}
} else {
/* mlib_f32 types */
b_step = nchan;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < size * nchan; i++) {
dstPixelPtr[i] = (DTYPE) sat_off;
}
}
ws->b_step = b_step;
/*
* move to kernel center
*/
x0 -= ws->x_move;
y0 -= ws->y_move;
ws->size = size;
ws->x0 = x0;
ws->y0 = y0;
for (k = 0; k < nchan; k++) {
#if IMG_TYPE < 4
DTYPE *dPtr = dstPixelPtr + k;
#endif /* IMG_TYPE < 4 */
ws->k = k;
if (type >= 4) {
buff = (void *)(dstPixelPtr + k);
}
for (l = 0; l < n; l += kh) {
/* kernel lines */
kh = n - l;
if (kh >= 4 && (m & 3) == 0)
kh = 4;
else if (kh >= 2)
kh = 2;
for (off = 0; off < m; off += kw) {
/* offset in current kernel line */
ws->x0 = x0 + (off << x_shift);
kw = m - off;
if (kw > 2 * MAX_KER)
kw = MAX_KER;
else if (kw > MAX_KER)
kw = kw / 2;
CALL_FUNC(8)
}
}
#if IMG_TYPE < 4
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif /* __SUNPRO_C */
for (i = 0; i < size; i++) {
FP_TYPE val = buff[i];
#if IMG_TYPE < 3 && defined(MLIB_USE_FTOI_CLAMPING)
mlib_s32 ival;
#endif /* IMG_TYPE < 3 && defined(MLIB_USE_FTOI_CLAMPING) */
SAT(dPtr[i * nchan], ival, val);
buff[i] = sat_off;
}
#endif /* IMG_TYPE < 4 */
}
}
if (type < 4) {
if (buff != buff_local)
__mlib_free(buff);
}
return (MLIB_SUCCESS);
}
void PhysicsContext::Simulate(float timeStep)
{
if (numCollidables <= 1)
return;
// Setup Frame
coarse.clear();
contacts.clear();
grid.FillGrid(m_Objects);
// Apply external forces
for (uint i = 0; i < numCollidables; ++i)
{
if (m_Objects[i].rigidbody)
{
//m_Objects[i].rigidbody->AddForce(Vector3(0.0f, -9.8f * timeStep, 0.0f));
}
}
for (int x = 0; x < grid.numCellsX; ++x)
{
for (int z = 0; z < grid.numCellsZ; ++z)
{
std::vector<PhysicsObject*> objs = grid.GetAllAdjacentObjects(x, z);
int num = objs.size();
if (num <= 1)
if (num < 2)
continue;
for (uint i = 0; i < num - 1; ++i)
{
Collider* c1 = objs[i]->collider;
for (uint j = i + 1; j < num; ++j)
{
Collider* c2 = objs[j]->collider;
CoarseContainer cc;
// NOTE: SAT IS NOT A COARSE COLLISION DETECTOR
if (SAT(c1, c2))
{
if (c1->GetIsTrigger() || c2->GetIsTrigger())
{
c1->GetGameObject()->OnTrigger(c2);
c2->GetGameObject()->OnTrigger(c1);
continue;
}
c1->GetGameObject()->OnCollision(c2);
c2->GetGameObject()->OnCollision(c1);
cc.collider1 = c1;
cc.collider2 = c2;
coarse.push_back(cc);
}
}
}
}
}
// Fine Collision Detection
for (uint i = 0; i < coarse.size(); ++i)
{
ContactContainer cc;
if (ContactGeneration(coarse[i].collider1, coarse[i].collider2, cc))
{
contacts.push_back(cc);
//std::cout << "Contact Point: " << cc.contactPoint << std::endl;
// std::cout << "Contact Normal: " << cc.contactNormal << std::endl;
}
}
// Collision Resolution
for (uint i = 0; i < contacts.size(); ++i)
{
ResolveCollisionSimple(contacts[i]);
continue;
//Rigidbody* r1 = contacts[i].rigidbody[0];
//Rigidbody* r2 = contacts[i].rigidbody[1];
//
//if (r1 && r2)
//{
// ResolveCollision(r1, r2);
// continue;
//}
//
//if (r1 && !r2)
//{
// ResolveCollision(r1, coarse[i].collider2);
// continue;
//}
//
//if (!r1 && r2)
//{
// ResolveCollision(r2, coarse[i].collider1);
// continue;
//}
}
// Integrate results
for (uint i = 0; i < numCollidables; ++i)
{
PhysicsObject c = m_Objects[i];
if (c.rigidbody)
{
c.rigidbody->Integrate();
}
}
}
