static int _removeOldAIS(void)
{
_ais_t *ais = NULL;
GTimeVal now;
if (NULL == _ais_list) {
g_print("s52ais:_getAIS() no AIS list\n");
return FALSE;
}
g_get_current_time(&now);
unsigned int i = 0;
for (i=0; i<_ais_list->len; ++i) {
ais = &g_array_index(_ais_list, _ais_t, i);
// AIS report older then 10 min
if (now.tv_sec > (ais->lastUpdate.tv_sec + AIS_SILENCE_MAX)) {
_setAISDel(ais);
g_array_remove_index_fast(_ais_list, i);
return TRUE;
}
}
return FALSE;
}
int oh_remove_domain_from_handler(unsigned int h_id,
SaHpiDomainIdT did)
{
gint i;
struct oh_handler *h;
data_access_lock();
h = oh_lookup_handler(h_id);
if (h == NULL) {
data_access_unlock();
return -1;
}
for (i = 0; ; i++) {
if (g_array_index(h->dids, SaHpiDomainIdT, i) == 0) {
break;
}
if (g_array_index(h->dids, SaHpiDomainIdT, i) == did) {
h->dids = g_array_remove_index_fast(h->dids, i);
data_access_unlock();
return 0;
}
}
data_access_unlock();
return -1;
}
gboolean
ibus_hotkey_profile_remove_hotkey_by_event (IBusHotkeyProfile *profile,
GQuark event)
{
IBusHotkeyProfilePrivate *priv;
priv = IBUS_HOTKEY_PROFILE_GET_PRIVATE (profile);
gint i;
IBusHotkeyEvent *p = NULL;
for ( i = 0; i < priv->events->len; i++) {
p = &g_array_index (priv->events, IBusHotkeyEvent, i);
if (p->event == event)
break;
}
if (p == NULL || p->event != event)
return FALSE;
GList *list;
for (list = p->hotkeys; list != NULL; list = list->next) {
g_tree_remove (priv->hotkeys, (IBusHotkey *)list->data);
}
g_list_free (p->hotkeys);
g_array_remove_index_fast (priv->events, i);
return TRUE;
}
static int key_press (Viewer *viewer, EventHandler *ehandler,
const GdkEventKey *event)
{
RendererGoal *self = (RendererGoal*) ehandler->user;
if (event->keyval == 'g' || event->keyval == 'G') {
if (viewer_picking(viewer))
return 0;
viewer_request_pick(viewer, ehandler);
if (!ehandler->picking)
return 0;
return 1;
}
if ((event->keyval == GDK_Delete || event->keyval == GDK_BackSpace) && ehandler->picking) {
ehandler->picking = 0;
int idx = self->edit_goal - &g_array_index (self->my_goals, lcmtypes_goal_t, 0);
g_array_remove_index_fast (self->my_goals, idx);
self->edit_goal = NULL;
return 1;
}
if (event->keyval == GDK_Escape && ehandler->picking) {
ehandler->picking = 0;
self->edit_goal = NULL;
return 1;
}
return 0;
}
GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
guint index_)
{
g_array_remove_index_fast ((GArray*) array, index_);
return array;
}
static void
_cleanup(struct grid_task_queue_s *gtq)
{
while (gtq->tasks->len > 0) {
struct grid_task_s *task = &g_array_index(gtq->tasks, struct grid_task_s, 0);
if (task->cleanup)
task->cleanup(task->u);
g_array_remove_index_fast(gtq->tasks, 0);
}
}
static int _updateTimeTag(void)
// then update time tag of AIS
{
if (NULL == _ais_list)
return FALSE;
/*
{ // check global time - update time tag of all AIS each sec
// FIXME: should be 0.5 sec
GTimeVal now;
g_get_current_time(&now);
if ((now.tv_sec-_timeTick.tv_sec) < 1)
return FALSE;
g_get_current_time(&_timeTick);
}
*/
// keep removing old AIS
while (TRUE == _removeOldAIS())
_dumpAIS();
GTimeVal now;
g_get_current_time(&now);
for (guint i=0; i<_ais_list->len; ++i) {
gchar str[127+1] = {'\0'};
_ais_t *ais = &g_array_index(_ais_list, _ais_t, i);
if (-1.0 != ais->course) {
#ifdef S52_USE_SOCK
g_snprintf(str, 127, "%s %lis%s%03.f deg / %3.1f kt", ais->name, (now.tv_sec - ais->lastUpdate.tv_sec), NL, ais->course, ais->speed);
#else
g_snprintf(str, 127, "%s %lis%c%03.f deg / %3.1f kt", ais->name, (now.tv_sec - ais->lastUpdate.tv_sec), (int)NL, ais->course, ais->speed);
#endif
} else {
g_snprintf(str, 127, "%s %lis", ais->name, now.tv_sec - ais->lastUpdate.tv_sec);
}
#ifdef S52_USE_SOCK
_encodeNsend("S52_setVESSELlabel", "%lu,\"%s\"", ais->vesselH, str);
#else
if (FALSE == S52_setVESSELlabel(ais->vesselH, str)) {
g_print("s52ais:_updateTimeTag(): FAIL setVESSELlabel = %s\n", str);
_setAISDel(ais);
g_array_remove_index_fast(_ais_list, i);
//g_assert(0);
}
#endif
}
return TRUE;
}
static int _delAIS (unsigned int mmsi)
{
for (guint i=0; i<_ais_list->len; ++i) {
_ais_t *ais = &g_array_index(_ais_list, _ais_t, i);
if (mmsi == ais->mmsi) {
g_array_remove_index_fast(_ais_list, i);
return TRUE;
}
}
return FALSE;
}
void Clavier_touche_relacher( Scene* scene, char* nomTouche )
{
int i = 0;
for( i = 0; i < scene->clavier->nbTouche; i++ )
{
if( strcmp( g_array_index( scene->clavier->tTouche, char*, i ), nomTouche) == 0 )
{
g_array_remove_index_fast( scene->clavier->tTouche, i );
scene->clavier->nbTouche--;
}
}
}
gint
is_permutation(a, b)
{
GArray *array_a, *array_b;
gint i = 0;
array_a = g_array_new(FALSE, FALSE, sizeof (gint));
array_b = g_array_new(FALSE, FALSE, sizeof (gint));
i = a % 10;
g_array_prepend_val(array_a, i);
i = b % 10;
g_array_prepend_val(array_b, i);
while(a > 0)
{
i = a % 10;
g_array_prepend_val(array_a, i);
a /= 10;
}
i = 0;
while(b > 0)
{
i = b % 10;
g_array_prepend_val(array_b, i);
b /= 10;
}
g_array_remove_index_fast(array_a, array_a->len-1);
g_array_remove_index_fast(array_b, array_b->len-1);
g_array_sort(array_a, compare);
g_array_sort(array_b, compare);
print_array(array_a);
print_array(array_b);
return 0;
}
void qio_ev_trigger(struct qio_ev *ev, struct qio *qio, const json_t *json)
{
guint i;
struct qio_ev_sub *sub;
for (i = 0; i < ev->subs->len; i++) {
sub = &g_array_index(ev->subs, struct qio_ev_sub, i);
sub->cb(qio, ev->ev_path, json, sub->data);
if (sub->once) {
g_array_remove_index_fast(ev->subs, i);
i--;
}
}
}
void qio_ev_rm(struct qio_ev *ev, qio_ev_cb_fn cb, void *data)
{
guint i;
struct qio_ev_sub *sub;
if (cb == NULL) {
g_array_set_size(ev->subs, 0);
} else {
for (i = 0; i < ev->subs->len; i++) {
sub = &g_array_index(ev->subs, struct qio_ev_sub, i);
if (sub->cb == cb && data != NULL ? sub->data == data : TRUE) {
g_array_remove_index_fast(ev->subs, i);
i--;
}
}
}
}
int main(int argc, char** argv) {
GArray* a = g_array_new(FALSE, FALSE, sizeof(int));
int x[6] = {1,2,3,4,5,6};
g_array_append_vals(a, &x, 6);
prt(a);
printf("Removing the first item\n");
g_array_remove_index(a, 0);
prt(a);
printf("Removing the first two items\n");
g_array_remove_range(a, 0, 2);
prt(a);
printf("Removing the first item very quickly\n");
g_array_remove_index_fast(a, 0);
prt(a);
g_array_free(a, FALSE);
return 0;
}
gboolean
ibus_hotkey_profile_remove_hotkey (IBusHotkeyProfile *profile,
guint keyval,
guint modifiers)
{
IBusHotkeyProfilePrivate *priv;
priv = IBUS_HOTKEY_PROFILE_GET_PRIVATE (profile);
IBusHotkey hotkey = {
.keyval = keyval,
.modifiers = modifiers
};
IBusHotkey *p1;
GQuark event;
gboolean retval;
retval = g_tree_lookup_extended (priv->hotkeys,
&hotkey,
(gpointer)&p1,
(gpointer)&event);
if (!retval)
return FALSE;
gint i;
IBusHotkeyEvent *p2 = NULL;
for ( i = 0; i < priv->events->len; i++) {
p2 = &g_array_index (priv->events, IBusHotkeyEvent, i);
if (p2->event == event)
break;
}
g_assert (p2->event == event);
p2->hotkeys = g_list_remove (p2->hotkeys, p1);
if (p2->hotkeys == NULL) {
g_array_remove_index_fast (priv->events, i);
}
g_tree_remove (priv->hotkeys, p1);
return TRUE;
}
/**
* gst_caps_features_remove_id:
* @features: a #GstCapsFeatures.
* @feature: a feature.
*
* Removes @feature from @features.
*
* Since: 1.2
*/
void
gst_caps_features_remove_id (GstCapsFeatures * features, GQuark feature)
{
guint i, n;
g_return_if_fail (features != NULL);
g_return_if_fail (IS_MUTABLE (features));
g_return_if_fail (feature != 0);
n = features->array->len;
for (i = 0; i < n; i++) {
GQuark quark = gst_caps_features_get_nth_id (features, i);
if (quark == feature) {
g_array_remove_index_fast (features->array, i);
return;
}
}
}
static void
remmina_plugin_nx_remove_window_id (Window window_id)
{
gint i;
gboolean found = FALSE;
pthread_mutex_lock (&remmina_nx_init_mutex);
for (i = 0; i < remmina_nx_window_id_array->len; i++)
{
if (g_array_index (remmina_nx_window_id_array, Window, i) == window_id)
{
found = TRUE;
break;
}
}
if (found)
{
g_array_remove_index_fast (remmina_nx_window_id_array, i);
}
pthread_mutex_unlock (&remmina_nx_init_mutex);
}
void vfs_file_monitor_remove( VFSFileMonitor * fm,
VFSFileMonitorCallback cb,
gpointer user_data )
{
int i;
VFSFileMonitorCallbackEntry* callbacks;
//printf( "vfs_file_monitor_remove\n" );
if ( !fm )
printf( " fm == NULL\n");
if ( cb && fm && fm->callbacks )
{
callbacks = ( VFSFileMonitorCallbackEntry* ) fm->callbacks->data;
for ( i = 0; i < fm->callbacks->len; ++i )
{
if ( callbacks[ i ].callback == cb && callbacks[ i ].user_data == user_data )
{
fm->callbacks = g_array_remove_index_fast ( fm->callbacks, i );
break;
}
}
}
if ( fm && g_atomic_int_dec_and_test( &fm->n_ref ) ) //MOD added "fm &&"
{
#ifdef USE_INOTIFY /* Linux inotify */
inotify_rm_watch ( inotify_fd, fm->wd );
#else /* Use FAM|gamin */
FAMCancelMonitor( &fam, &fm->request );
#endif
g_hash_table_remove( monitor_hash, fm->path );
g_free( fm->path );
g_array_free( fm->callbacks, TRUE );
g_slice_free( VFSFileMonitor, fm );
}
//printf( "vfs_file_monitor_remove DONE\n" );
}
static CK_SESSION_HANDLE
pop_session_table (GP11ModulePrivate *pv, CK_SLOT_ID slot, gulong flags)
{
CK_SESSION_HANDLE result = 0;
SessionPool *pool;
GArray **array;
g_return_val_if_fail (pv, 0);
if (!pv->open_sessions)
return 0;
pool = g_hash_table_lookup (pv->open_sessions, &slot);
if (pool == NULL)
return 0;
if (flags & CKF_RW_SESSION)
array = &pool->rw_sessions;
else
array = &pool->ro_sessions;
if (*array == NULL)
return 0;
g_assert ((*array)->len > 0);
result = g_array_index (*array, CK_SESSION_HANDLE, (*array)->len - 1);
g_assert (result != 0);
g_array_remove_index_fast (*array, (*array)->len - 1);
if (!(*array)->len) {
g_array_free (*array, TRUE);
*array = NULL;
if (!pool->rw_sessions && !pool->ro_sessions)
g_hash_table_remove (pv->open_sessions, &slot);
}
return result;
}
static void remmina_rdp_event_release_key(RemminaProtocolWidget* gp, gint scancode)
{
gint i, k;
rfContext* rfi;
RemminaPluginRdpEvent rdp_event = { 0 };
rfi = GET_DATA(gp);
rdp_event.type = REMMINA_RDP_EVENT_TYPE_SCANCODE;
if (scancode == 0)
{
/* Send all release key events for previously pressed keys */
rdp_event.key_event.up = True;
for (i = 0; i < rfi->pressed_keys->len; i++)
{
rdp_event.key_event.key_code = g_array_index(rfi->pressed_keys, gint, i);
remmina_rdp_event_event_push(gp, &rdp_event);
}
g_array_set_size(rfi->pressed_keys, 0);
}
else
{
/* Unregister the keycode only */
for (i = 0; i < rfi->pressed_keys->len; i++)
{
k = g_array_index(rfi->pressed_keys, gint, i);
if (k == scancode)
{
g_array_remove_index_fast(rfi->pressed_keys, i);
break;
}
}
}
}
void
_cogl_poll_renderer_remove_fd (CoglRenderer *renderer, int fd)
{
int i = find_pollfd (renderer, fd);
GList *l;
if (i < 0)
return;
g_array_remove_index_fast (renderer->poll_fds, i);
renderer->poll_fds_age++;
for (l = renderer->poll_sources; l; l = l->next)
{
CoglPollSource *source = l->data;
if (source->fd == fd)
{
renderer->poll_sources =
g_list_delete_link (renderer->poll_sources, l);
g_slice_free (CoglPollSource, source);
break;
}
}
}
void game_set_initial_configuration_position(game_t *game)
{
random_set_seed(time(NULL));
int n = game->graph->n;
GArray *players = g_array_new(FALSE, FALSE, sizeof(int));
int i;
for(i = 0; i < n; ++i)
{
game->initial_config[i] = 0;
game->current_config[i] = 0;
g_array_append_val(players, i);
}
mpq_t e;
mpq_init(e);
mpq_set_si(e, game->graph->n, 1);
mpq_mul(e, game->p_c, e);
int m = ROUND(mpq_get_d(e));
mpq_clear(e);
for(i = 0; i < m; ++i)
{
int j = random_integer(n);
int x = g_array_index(players, int, j);
game->initial_config[x] = 1;
game->current_config[x] = 1;
g_array_remove_index_fast(players, j);
n--;
}
g_array_free(players, TRUE);
}
// chain function; this function does the actual processing
static GstFlowReturn
gst_surf_tracker_chain(GstPad *pad, GstBuffer *buf) {
GstSURFTracker *filter;
GstClockTime timestamp;
// sanity checks
g_return_val_if_fail(pad != NULL, GST_FLOW_ERROR);
g_return_val_if_fail(buf != NULL, GST_FLOW_ERROR);
filter = GST_SURF_TRACKER(GST_OBJECT_PARENT(pad));
filter->image->imageData = (char*) GST_BUFFER_DATA(buf);
// Create the gray image for the surf 'features' search process
cvCvtColor(filter->image, filter->gray, CV_BGR2GRAY);
++filter->frames_processed;
timestamp = GST_BUFFER_TIMESTAMP(buf);
// If exist stored_objects: search matching, update, cleaning
if ((filter->stored_objects != NULL) && (filter->stored_objects->len > 0)) {
CvMemStorage *surf_image_mem_storage;
CvSeq *surf_image_keypoints, *surf_image_descriptors;
guint i;
gint j;
// Update the match set 'features' for each object
surf_image_mem_storage = cvCreateMemStorage(0);
// Search 'features' in full image
surf_image_keypoints = surf_image_descriptors = NULL;
cvExtractSURF(filter->gray, NULL, &surf_image_keypoints, &surf_image_descriptors,
surf_image_mem_storage, filter->params, 0);
for (i = 0; i < filter->stored_objects->len; ++i) {
InstanceObject *object;
GArray *pairs;
object = &g_array_index(filter->stored_objects, InstanceObject, i);
pairs = g_array_new(FALSE, FALSE, sizeof(IntPair));
findPairs(object->surf_object_keypoints, object->surf_object_descriptors,
surf_image_keypoints, surf_image_descriptors, pairs);
// if match, update object
if (pairs->len && (float) pairs->len / object->surf_object_descriptors->total >= MIN_MATCH_OBJECT) {
object->range_viewed++;
object->last_frame_viewed = filter->frames_processed;
object->timestamp = timestamp;
if (object->surf_object_keypoints_last_match != NULL)
cvClearSeq(object->surf_object_keypoints_last_match);
object->surf_object_keypoints_last_match = getMatchPoints(surf_image_keypoints, pairs, 1, object->mem_storage);
if (object->surf_object_descriptors_last_match != NULL)
cvClearSeq(object->surf_object_descriptors_last_match);
object->surf_object_descriptors_last_match = getMatchPoints(surf_image_descriptors, pairs, 1, object->mem_storage);
// Estimate rect of objects localized
object->rect_estimated = rectDisplacement(object->surf_object_keypoints, surf_image_keypoints, pairs, object->rect, PAIRS_PERC_CONSIDERATE);
}
g_array_free(pairs, TRUE);
}
if (surf_image_keypoints != NULL) cvClearSeq(surf_image_keypoints);
if (surf_image_descriptors != NULL) cvClearSeq(surf_image_descriptors);
cvReleaseMemStorage(&surf_image_mem_storage);
// Clean old objects
for (j = filter->stored_objects->len - 1; j >= 0; --j) {
InstanceObject *object;
object = &g_array_index(filter->stored_objects, InstanceObject, j);
if ((filter->frames_processed - object->last_frame_viewed > DELOBJ_NFRAMES_IS_OLD) ||
(filter->frames_processed != object->last_frame_viewed && object->range_viewed < DELOBJ_COMBOFRAMES_IS_IRRELEVANT)) {
if (object->surf_object_keypoints != NULL) cvClearSeq(object->surf_object_keypoints);
if (object->surf_object_descriptors != NULL) cvClearSeq(object->surf_object_descriptors);
if (object->surf_object_keypoints_last_match != NULL) cvClearSeq(object->surf_object_keypoints_last_match);
if (object->surf_object_descriptors_last_match != NULL) cvClearSeq(object->surf_object_descriptors_last_match);
cvReleaseMemStorage(&object->mem_storage);
g_array_remove_index_fast(filter->stored_objects, j);
}
}
} // if any object exist
// Process all haar rects
if ((filter->rect_array != NULL) && (filter->rect_array->len > 0)) {
guint i, j;
for (i = 0; i < filter->rect_array->len; ++i) {
CvRect rect = g_array_index(filter->rect_array, CvRect, i);
// If already exist in 'stored_objects', update features. Else save
// as new.
for (j = 0; j < filter->stored_objects->len; ++j) {
InstanceObject *object;
object = &g_array_index(filter->stored_objects, InstanceObject, j);
// It is considered equal if the "centroid match features" is inner
// haar rect AND max area deviation is PERC_RECT_TO_SAME_OBJECT
if (pointIntoRect(rect, (object->surf_object_keypoints_last_match != NULL) ? surfCentroid(object->surf_object_keypoints_last_match, cvPoint(0, 0)) : surfCentroid(object->surf_object_keypoints, cvPoint(0, 0))) &&
((float) MIN((object->rect.width * object->rect.height), (rect.width * rect.height)) / (float) MAX((object->rect.width * object->rect.height), (rect.width * rect.height)) >= PERC_RECT_TO_SAME_OBJECT)) {
// Update the object features secound the new body rect
cvSetImageROI(filter->gray, rect);
cvExtractSURF(filter->gray, NULL, &object->surf_object_keypoints, &object->surf_object_descriptors,
object->mem_storage, filter->params, 0);
cvResetImageROI(filter->gray);
object->rect = object->rect_estimated = rect;
object->last_body_identify_timestamp = timestamp;
break;
}
}
// If new, create object and append in stored_objects
if (j >= filter->stored_objects->len) {
InstanceObject object;
object.surf_object_keypoints = 0;
object.surf_object_descriptors = 0;
object.mem_storage = cvCreateMemStorage(0);
cvSetImageROI(filter->gray, rect);
cvExtractSURF(filter->gray, NULL, &object.surf_object_keypoints, &object.surf_object_descriptors,
object.mem_storage, filter->params, 0);
cvResetImageROI(filter->gray);
if (object.surf_object_descriptors && object.surf_object_descriptors->total > 0) {
object.id = filter->static_count_objects++;
object.last_frame_viewed = filter->frames_processed;
object.range_viewed = 1;
object.rect = object.rect_estimated = rect;
object.timestamp = object.last_body_identify_timestamp = timestamp;
object.surf_object_keypoints_last_match = NULL;
object.surf_object_descriptors_last_match = NULL;
g_array_append_val(filter->stored_objects, object);
}
} // new
}
}
// Put the objects found in the frame in gstreamer pad
if ((filter->stored_objects != NULL) && (filter->stored_objects->len > 0)) {
guint i;
for (i = 0; i < filter->stored_objects->len; ++i) {
InstanceObject object = g_array_index(filter->stored_objects, InstanceObject, i);
// 'Continue' whether the object is not found in this frame
if (object.timestamp == timestamp) {
TrackedObject *tracked_object;
GstEvent *event;
CvRect rect;
rect = ((object.last_body_identify_timestamp == timestamp) ? object.rect : object.rect_estimated);
if (filter->verbose) {
GST_INFO("[object #%d rect] x: %d, y: %d, width: %d, height: %d\n", object.id, rect.x, rect.y, rect.width, rect.height);
// drawSurfPoints(object.surf_object_keypoints, cvPoint(object.rect.x, object.rect.y), filter->image, PRINT_COLOR, 0);
// drawSurfPoints(object.surf_object_keypoints_last_match, cvPoint(object.rect.x, object.rect.y), filter->image, PRINT_COLOR, 1);
}
if (filter->display_features) {
drawSurfPoints(object.surf_object_keypoints_last_match, cvPoint(0, 0), filter->image, PRINT_COLOR, 1);
}
if (filter->display) {
char *label;
float font_scaling;
font_scaling = ((filter->image->width * filter->image->height) > (320 * 240)) ? 0.5f : 0.3f;
cvRectangle(filter->image, cvPoint(rect.x, rect.y), cvPoint(rect.x + rect.width, rect.y + rect.height),
PRINT_COLOR, ((object.last_body_identify_timestamp == timestamp) ? 2 : 1), 8, 0);
label = g_strdup_printf("OBJ#%i", object.id);
printText(filter->image, cvPoint(rect.x + (rect.width / 2), rect.y + (rect.height / 2)), label, PRINT_COLOR, font_scaling, 1);
g_free(label);
}
// allocate and initialize 'TrackedObject' structure
tracked_object = tracked_object_new();
tracked_object->id = g_strdup_printf("PERSON#%d", object.id);
tracked_object->type = TRACKED_OBJECT_DYNAMIC;
tracked_object->height = rect.height;
tracked_object->timestamp = timestamp;
// add the points that the define the lower part of the object (i.e,
// the lower horizontal segment of the rectangle) as the objects perimeter
tracked_object_add_point(tracked_object, rect.x, rect.y + rect.height);
tracked_object_add_point(tracked_object, rect.x + rect.width, rect.y + rect.height);
// send downstream event
event = gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM,
tracked_object_to_structure(tracked_object, "tracked-object"));
gst_pad_push_event(filter->srcpad, event);
}
}
}
// Clean body rects
g_array_free(filter->rect_array, TRUE);
filter->rect_array = g_array_sized_new(FALSE, FALSE, sizeof(CvRect), 1);
// Draw number of objects stored
if (filter->display) {
char *label = g_strdup_printf("N_STORED_OBJS: %3i", filter->stored_objects->len);
printText(filter->image, cvPoint(0, 0), label, PRINT_COLOR, .5, 1);
g_free(label);
}
gst_buffer_set_data(buf, (guint8*) filter->image->imageData, (guint) filter->image->imageSize);
return gst_pad_push(filter->srcpad, buf);
}
FullTree* qsearch_make_fulltree(QSearchTree *clt, const gsl_matrix *dm) {
int i,j;
int node_count = clt->total_node_count;
int leaf_count = (node_count + 2)/2;
FullTree *tree = malloc(sizeof(FullTree));
tree->node_count = node_count;
tree->data = malloc(sizeof(Misc));
((Misc *)tree->data)->nodes = malloc(sizeof(FullNode) * node_count);
((Misc *)tree->data)->tmpA = g_array_sized_new(FALSE, FALSE, sizeof(guint32), node_count);
((Misc *)tree->data)->tmpB = g_array_sized_new(FALSE, FALSE, sizeof(guint32), node_count);
FullNode *map = get_nodes(tree);
GArray *todo = g_array_sized_new(FALSE, FALSE, sizeof(guint32), node_count - leaf_count);
g_array_set_size(todo, node_count-leaf_count);
for (i = 0; i < node_count; ++i) {
FullNode *node = (map + i);
for (j = 0; j < 3; ++j) {
map[i].connections[j] = -1;
map[i].leaf_count[j] = 0;
map[i].dist[j] = 0;
}
guint8 *node_branch = malloc(sizeof(guint8) * node_count);
node->node_branch = node_branch;
if (i < leaf_count) {
for (j=0; j < node_count; ++j) node_branch[j] = 0;
node->leaf_count[0] = leaf_count - 1;
} else {
for (j = 0; j < node_count; ++j) node_branch[j] = -1;
g_array_index(todo, guint32, i - leaf_count) = i;
}
}
// set connections (construct tree)
for (i = 0; i < node_count; ++i) {
QSearchNeighborList *cln = g_ptr_array_index(clt->n, i);
// add to connected nodes
for (j = 0; j < cln->n->len; ++j) {
int node = g_array_index(cln->n, guint32, j);
// find unfilled branch
int branch = find_branch(map[node].connections, -1);
map[node].connections[branch] = i; // set connection
if (i < leaf_count) {
map[node].leaf_count[branch] = 1; // set leaf
}
map[node].node_branch[i] = branch; // leaf can be found in branch
// set connection back to this node
branch = find_branch(map[i].connections, -1);
map[i].connections[branch] = node;
map[i].node_branch[node] = branch;
}
}
// every iteration, this loop progresses by at least finishing one node. Worst case is n^3 (for 'linear' trees)
while (todo->len > 0) {
for (i = 0; i < todo->len; ++i) {
int this_node = g_array_index(todo, guint32, i);
for (j = 0; j < 3; ++j) {
int connected_node = map[this_node].connections[j];
int branch = find_branch(map[connected_node].connections, this_node);
if (map[connected_node].leaf_count[branch] == 0) {
int first = (3 + j-1) % 3;
int second = (j + 1) % 3;
if (map[this_node].leaf_count[first] != 0 && map[this_node].leaf_count[second] != 0) {
map[connected_node].leaf_count[branch] = map[this_node].leaf_count[first] + map[this_node].leaf_count[second];
// set the node_branch information
int k;
for (k = 0; k < node_count; ++k) {
// node present in one of the two branches pointing away from this
int node_present = k==this_node || map[this_node].node_branch[k] == first || map[this_node].node_branch[k] == second;
if (node_present) map[connected_node].node_branch[k] = branch;
}
}
}
}
}
for (i = 0; i < todo->len; ++i) {
int this_node = g_array_index(todo, guint32, i);
// we are done when all entries are set for this node, AND there are no pending assignments to neighbours
// are all entries set for this node?
for (j = 0; j < 3; ++j) {
if (map[this_node].leaf_count[j] == 0) {
break;
}
}
// are there pending assignments? (we could do the assignments here, but that would duplicate code)
int done = 1;
for (j = 0; j < 3; ++j) {
if (this_node < leaf_count) continue;
int connected_node = map[this_node].connections[j];
// find connection
int branch = find_branch(map[connected_node].connections, this_node);
if (map[connected_node].leaf_count[branch] == 0) {
done = 0;
break;
}
}
if (done) {
//printf("Removing node %d, counts %d %d %d\n", i, map[this_node].leaf_count[0], map[this_node].leaf_count[1], map[this_node].leaf_count[2]);
g_array_remove_index_fast(todo, i);
--i;
}
}
}
g_array_free(todo, TRUE);
int k;
// now fill in the distances
for (i=leaf_count; i < node_count; ++i) {
for (j = 0; j < leaf_count; ++j) {
for (k = j+1; k < leaf_count; ++k) {
int b1 = map[i].node_branch[j];
int b2 = map[i].node_branch[k];
if (b1 == b2) continue;
int b3 = 3 - b1 - b2;
map[i].dist[b3] += gsl_matrix_get(dm, j, k);
}
}
}
set_score(tree);
return tree;
}
/**
* @brief Process Key Input and return the status
*
* @param keycode keycode from XKeyEvent
* @param state state from XKeyEvent
* @param count count from XKeyEvent
* @return INPUT_RETURN_VALUE
**/
__EXPORT_API
INPUT_RETURN_VALUE FcitxLibpinyinDoInput(void* arg, FcitxKeySym sym, unsigned int state)
{
FcitxLibpinyin* libpinyin = (FcitxLibpinyin*) arg;
FcitxLibpinyinConfig* config = &libpinyin->owner->config;
FcitxInputState* input = FcitxInstanceGetInputState(libpinyin->owner->owner);
if (FcitxHotkeyIsHotKeySimple(sym, state))
{
/* there is some special case that ';' is used */
if (FcitxHotkeyIsHotKeyLAZ(sym, state)
|| sym == '\''
|| (FcitxHotkeyIsHotKey(sym, state, FCITX_SEMICOLON) && libpinyin->type == LPT_Shuangpin && (config->spScheme == FCITX_SHUANG_PIN_MS || config->spScheme == FCITX_SHUANG_PIN_ZIGUANG))
|| (libpinyin->type == LPT_Zhuyin && LibpinyinCheckZhuyinKey(sym, config->zhuyinLayout, config->useTone))
)
{
if (strlen(libpinyin->buf) == 0 && (sym == '\'' || sym == ';'))
return IRV_TO_PROCESS;
if (strlen(libpinyin->buf) < MAX_PINYIN_INPUT)
{
size_t len = strlen(libpinyin->buf);
if (libpinyin->buf[libpinyin->cursor_pos] != 0)
{
memmove(libpinyin->buf + libpinyin->cursor_pos + 1, libpinyin->buf + libpinyin->cursor_pos, len - libpinyin->cursor_pos);
}
libpinyin->buf[len + 1] = 0;
libpinyin->buf[libpinyin->cursor_pos] = (char) (sym & 0xff);
libpinyin->cursor_pos ++;
size_t parselen = FcitxLibpinyinParse(libpinyin, libpinyin->buf);
if (parselen == 0 && strlen(libpinyin->buf) == 1 && libpinyin->type != LPT_Shuangpin
&& !(libpinyin->type == LPT_Pinyin && !libpinyin->owner->config.incomplete)
&& !(libpinyin->type == LPT_Zhuyin && !libpinyin->owner->config.chewingIncomplete))
{
FcitxLibpinyinReset(libpinyin);
return IRV_TO_PROCESS;
}
return IRV_DISPLAY_CANDWORDS;
}
else
return IRV_DO_NOTHING;
}
}
if (FcitxHotkeyIsHotKey(sym, state, FCITX_SPACE)
|| (libpinyin->type == LPT_Zhuyin && FcitxHotkeyIsHotKey(sym, state, FCITX_ENTER)))
{
size_t len = strlen(libpinyin->buf);
if (len == 0)
return IRV_TO_PROCESS;
return FcitxCandidateWordChooseByIndex(FcitxInputStateGetCandidateList(input), 0);
}
if (FcitxHotkeyIsHotKey(sym, state, FCITX_LIBPINYIN_SHIFT_ENTER)) {
size_t len = strlen(libpinyin->buf);
if (len == 0)
return IRV_TO_PROCESS;
strcpy(FcitxInputStateGetOutputString(input), libpinyin->buf);
return IRV_COMMIT_STRING;
}
if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE) || FcitxHotkeyIsHotKey(sym, state, FCITX_DELETE))
{
if (strlen(libpinyin->buf) > 0)
{
int offset = LibpinyinGetOffset(libpinyin);
if (offset != 0 && FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE))
{
g_array_remove_index_fast(libpinyin->fixed_string, libpinyin->fixed_string->len - 1);
pinyin_clear_constraint(libpinyin->inst, LibpinyinGetOffset(libpinyin));
}
else
{
if (FcitxHotkeyIsHotKey(sym, state, FCITX_BACKSPACE))
{
if (libpinyin->cursor_pos > 0)
libpinyin->cursor_pos -- ;
else
return IRV_DO_NOTHING;
}
size_t len = strlen(libpinyin->buf);
if (libpinyin->cursor_pos == (int)len)
return IRV_DO_NOTHING;
memmove(libpinyin->buf + libpinyin->cursor_pos, libpinyin->buf + libpinyin->cursor_pos + 1, len - libpinyin->cursor_pos - 1);
libpinyin->buf[strlen(libpinyin->buf) - 1] = 0;
if (libpinyin->buf[0] == '\0')
return IRV_CLEAN;
else
FcitxLibpinyinParse(libpinyin, libpinyin->buf);
}
return IRV_DISPLAY_CANDWORDS;
}
else
return IRV_TO_PROCESS;
}
else
{
if (strlen(libpinyin->buf) > 0)
{
if (FcitxHotkeyIsHotKey(sym, state, FCITX_LEFT))
{
if (libpinyin->cursor_pos > 0)
{
if ( libpinyin->cursor_pos == LibpinyinGetPinyinOffset(libpinyin))
{
g_array_remove_index_fast(libpinyin->fixed_string, libpinyin->fixed_string->len - 1);
pinyin_clear_constraint(libpinyin->inst, LibpinyinGetOffset(libpinyin));
return IRV_DISPLAY_CANDWORDS;
}
else
{
libpinyin->cursor_pos--;
return IRV_DISPLAY_CANDWORDS;
}
}
return IRV_DO_NOTHING;
}
else if (FcitxHotkeyIsHotKey(sym, state, FCITX_RIGHT))
{
size_t len = strlen(libpinyin->buf);
if (libpinyin->cursor_pos < (int) len)
{
libpinyin->cursor_pos ++ ;
return IRV_DISPLAY_CANDWORDS;
}
return IRV_DO_NOTHING;
}
else if (FcitxHotkeyIsHotKey(sym, state, FCITX_HOME))
{
int offset = LibpinyinGetPinyinOffset(libpinyin);
if ( libpinyin->cursor_pos != offset)
{
libpinyin->cursor_pos = offset;
return IRV_DISPLAY_CANDWORDS;
}
return IRV_DO_NOTHING;
}
else if (FcitxHotkeyIsHotKey(sym, state, FCITX_END))
{
size_t len = strlen(libpinyin->buf);
if (libpinyin->cursor_pos != (int) len)
{
libpinyin->cursor_pos = len ;
return IRV_DISPLAY_CANDWORDS;
}
return IRV_DO_NOTHING;
}
}
else {
return IRV_TO_PROCESS;
}
}
return IRV_TO_PROCESS;
}
gboolean
p2tr_pslg_visibility_check (P2trPSLG *pslg,
P2trVector2 *point,
P2trPSLG *polygon)
{
P2trPSLG *known_blocks;
GArray *second_points;
gboolean found_visibility_path = FALSE;
/* W <- Some point in T (for example, center of weight) */
P2trVector2 W;
find_point_in_polygon (polygon, &W);
/* KnownBlocks <- {} */
known_blocks = p2tr_pslg_new ();
/* SecondPoint <- {W} */
second_points = g_array_new (FALSE, FALSE, sizeof(P2trVector2));
g_array_append_val (second_points, W);
while ((! found_visibility_path) && second_points->len > 0)
{
P2trVector2 S;
P2trBoundedLine PS;
P2trVector2 poly_intersection;
/* S <- Some point from SecondPoint */
p2tr_vector2_copy (&S, &g_array_index(second_points, P2trVector2, 0));
/* SecondPoint <- SecondPoint \ {S} */
g_array_remove_index_fast (second_points, 0);
/* PS <- The infinite line going through P and S */
p2tr_bounded_line_init (&PS, &S, point);
/* IF PS intersects @Poly */
if (find_closest_intersection (polygon, &PS.infinite, point, &poly_intersection))
{
P2trBoundedLine PS_exact, *B;
/* IF there is an edge B=(u,v) (from E) that intersects PS */
p2tr_bounded_line_init (&PS_exact, point, &poly_intersection);
B = pslg_line_intersection (pslg, &PS_exact);
if (B != NULL)
{
/* IF B is not in KnownBlocks: */
if (! p2tr_pslg_contains_line (known_blocks, B))
{
/* SecondPoint <- SecondPoint + {u,v} */
g_array_append_val (second_points, B->start);
g_array_append_val (second_points, B->end);
/* KnownBlocks <- KnownBlocks + {B} */
p2tr_pslg_add_existing_line (known_blocks, B);
}
}
else
{
found_visibility_path = TRUE;
}
}
}
g_array_free (second_points, TRUE);
p2tr_pslg_free (known_blocks);
return found_visibility_path;
}
/**
* Clean up any finished TID request processes
*
* This is called by the main process after forking each TID request. If you want to be
* sure finished processes are cleaned up promptly even during a lull in TID requests,
* this can be called from the main thread of the main process. It is not thread-safe,
* so should not be used from sub-threads. It should not be called by child processes -
* this would probably be harmless but ineffective.
*
* @param tids
*/
void tids_sweep_procs(TIDS_INSTANCE *tids)
{
guint ii;
struct tid_process tp = {0};
char result[TIDS_MAX_MESSAGE_LEN] = {0};
ssize_t result_len;
int status;
int wait_rc;
/* loop backwards over the array so we can remove elements as we go */
for (ii=tids->pids->len; ii > 0; ii--) {
/* ii-1 is the current index - get our own copy, we may destroy the list's copy */
tp = g_array_index(tids->pids, struct tid_process, ii-1);
wait_rc = waitpid(tp.pid, &status, WNOHANG);
if (wait_rc == 0)
continue; /* process still running */
if (wait_rc < 0) {
/* invalid options will probably keep being invalid, report that condition */
if(errno == EINVAL)
tr_crit("tids_sweep_procs: waitpid called with invalid options");
/* If we got ECHILD, that means the PID was invalid; we'll assume the process was
* terminated and we missed it. For all other errors, move on
* to the next PID to check. */
if (errno != ECHILD)
continue;
tr_warning("tid_sweep_procs: TID process %d disappeared", tp.pid);
}
/* remove the item (we still have a copy of the data) */
g_array_remove_index_fast(tids->pids, ii-1); /* disturbs only indices >= ii-1 which we've already handled */
/* Report exit status unless we got ECHILD above or somehow waitpid returned the wrong pid */
if (wait_rc == tp.pid) {
if (WIFEXITED(status)) {
tr_debug("tids_sweep_procs: TID process %d exited with status %d.", tp.pid, WTERMSIG(status));
} else if (WIFSIGNALED(status)) {
tr_debug("tids_sweep_procs: TID process %d terminated by signal %d.", tp.pid, WTERMSIG(status));
}
} else if (wait_rc > 0) {
tr_err("tids_sweep_procs: waitpid returned pid %d, expected %d", wait_rc, tp.pid);
}
/* read the pipe - if the TID request worked, it will have written status before terminating */
result_len = read(tp.read_fd, result, TIDS_MAX_MESSAGE_LEN);
close(tp.read_fd);
if ((result_len > 0) && (strcmp(result, TIDS_SUCCESS_MESSAGE) == 0)) {
tids->req_count++;
tr_info("tids_sweep_procs: TID process %d exited after successful request.", tp.pid);
} else if ((result_len > 0) && (strcmp(result, TIDS_ERROR_MESSAGE) == 0)) {
tids->req_error_count++;
tr_info("tids_sweep_procs: TID process %d exited after unsuccessful request.", tp.pid);
} else {
tids->error_count++;
tr_info("tids_sweep_procs: TID process %d exited with an error.", tp.pid);
}
}
}
