/* ==================================== */
void empilevoisins(int32_t x, int32_t rs, int32_t N, Fifo *FIFOna, Fifo *FIFOea, Fifo *FIFOsa, Fifo *FIFOoa)
/* ==================================== */
{
int32_t y, z, k;
/* x est un point qui vient de passer a 0 */
for (k = 0; k < 8; k++)
{
y = voisin(x, k, rs, N);
if ((y!=-1) && !IsSet(y,MINI) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{
z = voisin(y, NORD, rs, N);
if ((z != 0) && IsSet(z, MINI))
{ FifoPush(FIFOna, y); Set(y, EN_FIFO); goto nextk; }
z = voisin(y, SUD, rs, N);
if ((z != 0) && IsSet(z, MINI))
{ FifoPush(FIFOsa, y); Set(y, EN_FIFO); goto nextk; }
z = voisin(y, EST, rs, N);
if ((z != 0) && IsSet(z, MINI))
{ FifoPush(FIFOea, y); Set(y, EN_FIFO); goto nextk; }
z = voisin(y, OUEST, rs, N);
if ((z != 0) && IsSet(z, MINI))
{ FifoPush(FIFOoa, y); Set(y, EN_FIFO); goto nextk; }
}
nextk: ;
}
} /* empilevoisins() */
void FifoPushLastFinished()
{
if (skiersFinished == 0)
{
FifoPush(skierDB[MAX_SKIERS_ON_DB - 1]);
}
else
{
FifoPush(skierDB[skiersFinished-1]);
}
}
/* ==================================== */
void testmini(uint8_t *SOURCE, int32_t x, int32_t rs, int32_t N, Fifo *FIFO)
/* ==================================== */
{
int32_t k, y, kk, yy, w;
uint8_t valmin;
#ifdef REGULARISE
for (k = 0; k < 8; k += 2) /* parcourt les voisins en 4-connexite */
{ /* pour voir s'il existe un minimum voisin */
y = voisin(x, k, rs, N); /* a un niveau > a celui atteint par x */
if ((y != -1) && (IsSet(y, MINI)) && (SOURCE[y] > SOURCE[x]))
{ /* ce n'est plus un minimum */
FifoPush(FIFO, y);
UnSet(y, MINI);
valmin = SOURCE[y];
while (! FifoVide(FIFO)) /* parcours pour demarquer l'ex minimum */
{
w = FifoPop(FIFO);
for (kk = 0; kk < 8; kk += 2)
{
yy = voisin(w, kk, rs, N);
if ((yy != -1) && (SOURCE[yy] == valmin) && (IsSet(yy, MINI)))
{
FifoPush(FIFO, yy);
UnSet(yy, MINI);
}
} /* for kk ... */
} /* while (! FifoVide(FIFO)) */
} /* if ((y != -1) && (IsSet(y, MINI)) && (SOURCE[y] > SOURCE[x])) */
} /* for k */
#endif
for (k = 0; k < 8; k += 2) /* parcourt les voisins en 4-connexite */
{ /* pour voir s'il existe un minimum */
y = voisin(x, k, rs, N); /* au niveau atteint par x */
if ((y != -1) && (IsSet(y, MINI)) && (SOURCE[y] == SOURCE[x]))
{
Set(x, MINI);
break;
}
} /* for k */
} /* testmini() */
uint8_t UartMcuPutChar( Uart_t *obj, uint8_t data )
{
if( IsFifoFull( &obj->FifoTx ) == false )
{
__disable_irq( );
FifoPush( &obj->FifoTx, data );
__enable_irq( );
// Enable the USART Transmit interrupt
USART_ITConfig( USART1, USART_IT_TXE, ENABLE );
return 0; // OK
}
return 1; // Busy
}
/*************************************************************************
* Function Name: Uart2Isr
* Parameters: none
*
* Return: none
*
* Description: UART 2 interrupt routine
*
*************************************************************************/
void Uart2Isr(void)
{
Int8U Data;
// Recognizing the interrupt event
if(USART_GetFlagStatus(USART2,USART_FLAG_ORE))
{
USART_ClearFlag(USART2,USART_FLAG_ORE);
// Overrun Error
Uart2LineEvents.bOE = TRUE;
}
if(USART_GetFlagStatus(USART2,USART_FLAG_FE))
{
USART_ClearFlag(USART2,USART_FLAG_FE);
// Framing Error
Uart2LineEvents.bFE = TRUE;
}
if(USART_GetFlagStatus(USART2,USART_FLAG_NE))
{
USART_ClearFlag(USART2,USART_FLAG_NE);
// Noise Error
Uart2LineEvents.bFE = TRUE;
}
if(USART_GetFlagStatus(USART2,USART_FLAG_PE))
{
USART_ClearFlag(USART2,USART_FLAG_PE);
// Parity Error
Uart2LineEvents.bPE = TRUE;
}
// Push a new data into the receiver buffer
if(USART_GetFlagStatus(USART2,USART_FLAG_RXNE))
{
// Push a new data into the receiver buffer
if(!FifoPush(pUart2RxFifo,USART_ReceiveData(USART2)))
{
// the FIFO is full
Uart2LineEvents.bOE = TRUE;
}
}
if( USART_GetFlagStatus(USART2,USART_FLAG_TXE)
&& (USART_GetITStatus (USART2,USART_IT_TXE) == SET))
{
if(FifoPop(pUart2TxFifo,&Data))
{
USART_SendData(USART2,Data);
}
else
{
USART_ITConfig(USART2,USART_IT_TXE ,DISABLE);
}
}
}
/**
* @brief VCP_DataRx
* Data received over USB OUT endpoint are sent over CDC interface
* through this function.
*
* @note
* This function will block any OUT packet reception on USB endpoint
* untill exiting this function. If you exit this function before transfer
* is complete on CDC interface (ie. using DMA controller) it will result
* in receiving more data while previous ones are still not sent.
*
* @param Buf: Buffer of data to be received
* @param Len: Number of data received (in bytes)
* @retval Result of the opeartion: USBD_OK if all operations are OK else VCP_FAIL
*/
static uint16_t VCP_DataRx (uint8_t* Buf, uint32_t Len)
{
uint32_t i;
if( IsFifoEmpty( &FifoRx ) == true )
{
for( i = 0; i < Len; i++ )
{
FifoPush( &FifoRx, Buf[i] );
}
}
return USBD_OK;
}
void USART1_IRQHandler( void )
{
uint8_t data;
if( USART_GetITStatus( USART1, USART_IT_TXE ) != RESET )
{
//GpioWrite( &LedRed, 0 );
if( IsFifoEmpty( &Uart1.FifoTx ) == false )
{
data = FifoPop( &Uart1.FifoTx );
// Write one byte to the transmit data register
USART_SendData( USART1, data );
}
else
{
// Disable the USART Transmit interrupt
USART_ITConfig( USART1, USART_IT_TXE, DISABLE );
}
if( Uart1.IrqNotify != NULL )
{
Uart1.IrqNotify( UART_NOTIFY_TX );
}
//GpioWrite( &LedRed, 1 );
}
if( USART_GetITStatus( USART1, USART_IT_ORE_RX ) != RESET )
{
USART_ReceiveData( USART1 );
}
if( USART_GetITStatus( USART1, USART_IT_RXNE ) != RESET )
{
//UartPrintf( &Uart1, "USART_GetITStatus( USART1, USART_IT_RXNE )\n" );
//GpioWrite( &LedGreen, 0 );
data = USART_ReceiveData( USART1 );
if( IsFifoFull( &Uart1.FifoRx ) == false )
{
// Read one byte from the receive data register
FifoPush( &Uart1.FifoRx, data );
}
if( Uart1.IrqNotify != NULL )
{
Uart1.IrqNotify( UART_NOTIFY_RX );
}
//GpioWrite( &LedGreen, 1 );
}
}
uint8_t UartUsbPutChar( Uart_t *obj, uint8_t data )
{
if( UsbMcuIsDeviceConfigured( ) == false )
{
return 2;
}
if( IsFifoFull( &obj->FifoTx ) == false )
{
__disable_irq( );
FifoPush( &obj->FifoTx, data );
__enable_irq( );
if( UsbPacketTx == 1 )
{
/*Sent flag*/
UsbPacketTx = 0;
SetEPTxCount( ENDP1, 0 );
SetEPTxValid( ENDP1 );
}
return 0; // OK
}
return 1; // Busy
// if( UsbPacketTx == 1 )
// {
// /*Sent flag*/
// UsbPacketTx = 0;
// /* send packet to PMA*/
// UserToPMABufferCopy( ( unsigned char* )&data, ENDP1_TXADDR, 1 );
// SetEPTxCount( ENDP1, 1 );
// SetEPTxValid( ENDP1 );
// return 0; // OK
// }
// else
// {
// if( IsFifoFull( &obj->FifoTx ) == false )
// {
// __disable_irq( );
// FifoPush( &obj->FifoTx, data );
// __enable_irq( );
// return 0; // OK
// }
// }
// return 1; // Busy
}
/*************************************************************************
* Function Name: UartWrite
* Parameters: UartNum_t Uart, pInt8U pBuffer, Int32U BufferSize
*
* Return: Int32U
*
* Description: Write a data to UART. Return number of successful
* transmitted bytes
*
*************************************************************************/
Int32U UartWrite(UartNum_t Uart, pInt8U pBuffer, Int32U BufferSize)
{
Int32U Count = 0;
pUartFifo_t pUartFifo;
USART_TypeDef * pUart;
switch(Uart)
{
case UART_1:
pUart = USART1;
pUartFifo = pUart1TxFifo;
break;
case UART_2:
pUart = USART2;
pUartFifo = pUart2TxFifo;
break;
case UART_3:
pUart = USART3;
pUartFifo = pUart3TxFifo;
break;
default:
return(0);
}
if(BufferSize != 0)
{
ENTR_CRT_SECTION();
if(pUartFifo->PopIndx == pUartFifo->PushIndx)
{
USART_SendData(pUart,*pBuffer);
USART_ITConfig(pUart,USART_IT_TXE ,ENABLE);
++Count;
}
for ( ; Count < BufferSize; ++Count)
{
if(!FifoPush(pUartFifo,*(pBuffer+Count)))
{
break;
}
}
EXT_CRT_SECTION();
}
return(Count);
}
/**
* @brief CDC_Receive_FS
* Data received over USB OUT endpoint are sent over CDC interface
* through this function.
*
* @note
* This function will block any OUT packet reception on USB endpoint
* untill exiting this function. If you exit this function before transfer
* is complete on CDC interface (ie. using DMA controller) it will result
* in receiving more data while previous ones are still not sent.
*
* @param Buf: Buffer of data to be received
* @param Len: Number of data received (in bytes)
* @retval Result of the operation: USBD_OK if all operations are OK else USBD_FAIL
*/
int8_t CDC_Receive_FS (uint8_t* Buf, uint32_t *Len)
{
uint8_t i;
for( i = 0; i < *Len; i++ )
{
if( IsFifoFull( &UartObj->FifoRx ) == false )
{
// Read one byte from the receive data register
FifoPush( &UartObj->FifoRx, Buf[i] );
}
}
if( UartObj->IrqNotify != NULL )
{
UartObj->IrqNotify( UART_NOTIFY_RX );
}
USBD_CDC_SetRxBuffer(hUsbDevice_0, Buf);
USBD_CDC_ReceivePacket(hUsbDevice_0);
return (USBD_OK);
}
void EP3_OUT_Callback(void)
{
uint8_t i;
UsbRxLength = GetEPRxCount( ENDP3 );
PMAToUserBufferCopy( ( unsigned char* )UsbRxBuffer, ENDP3_RXADDR, UsbRxLength );
for( i = 0; i < UsbRxLength; i++ )
{
if( IsFifoFull( &UartUsb.FifoRx ) == false )
{
// Read one byte from the receive data register
FifoPush( &UartUsb.FifoRx, UsbRxBuffer[i] );
}
}
if( UartUsb.IrqNotify != NULL )
{
UartUsb.IrqNotify( UART_NOTIFY_RX );
}
}
uint8_t UartMcuPutChar( Uart_t *obj, uint8_t data )
{
if( IsFifoFull( &obj->FifoTx ) == false )
{
__disable_irq( );
FifoPush( &obj->FifoTx, data );
__enable_irq( );
// Enable the USART Transmit interrupt
switch ( obj->UartId )
{
case UART_1:
USART_ITConfig( USART1, USART_IT_TXE, ENABLE );
break;
case UART_2:
USART_ITConfig( USART2, USART_IT_TXE, ENABLE );
break;
}
//USART_ITConfig( USART1, USART_IT_TXE, ENABLE );
return 0; // OK
}
return 1; // Busy
}
/* ==================================== */
int32_t lselectcomp(
struct xvimage *f,
int32_t connex,
int32_t x,
int32_t y,
int32_t z)
/* extrait la composante connexe de f (image binaire)
qui contient le point (x,y,z) */
/* connex : 4, 8 (en 2D), 6, 18, 26 (en 3D) */
/* connex : 60, 260 (en 3D): idem 6 et 26 mais dans le plan xy seulement */
/* ==================================== */
#undef F_NAME
#define F_NAME "lselectcomp"
{
int32_t i; /* index muet de pixel */
int32_t j; /* index muet (generalement un voisin de x) */
int32_t k; /* index muet */
int32_t rs = rowsize(f); /* taille ligne */
int32_t cs = colsize(f); /* taille colonne */
int32_t ds = depth(f); /* nb plans */
int32_t ps = rs * cs; /* taille plan */
int32_t N = ps * ds; /* taille image */
uint8_t *F = UCHARDATA(f);
Fifo * FIFO;
int32_t incr_vois;
switch (connex)
{
case 4: incr_vois = 2; break;
case 8: incr_vois = 1; break;
} /* switch (connex) */
FIFO = CreeFifoVide(N);
if (FIFO == NULL)
{ fprintf(stderr,"%s : CreeFifoVide failed\n", F_NAME);
return(0);
}
for (i = 0; i < N; i++) if (F[i]) F[i] = 254;
i = z*ps + y*rs + x;
if (F[i]) { FifoPush(FIFO, i); F[i] += 1; }
if ((connex == 4) || (connex == 8))
{
if (ds != 1)
{ fprintf(stderr,"%s : connexity 4 or 8 not defined for 3D\n", F_NAME);
return(0);
}
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 8; k += incr_vois)
{
j = voisin(i, k, rs, N);
if ((j != -1) && (F[j]==254)) { FifoPush(FIFO, j); F[j] += 1; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 6)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 6 not defined for 2D\n", F_NAME);
return(0);
}
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k <= 10; k += 2)
{
j = voisin6(i, k, rs, ps, N);
if ((j != -1) && (F[j]==254)) { FifoPush(FIFO, j); F[j] += 1; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 18)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 18 not defined for 2D\n", F_NAME);
return(0);
}
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 18; k += 1)
{
j = voisin18(i, k, rs, ps, N);
if ((j != -1) && (F[j]==254)) { FifoPush(FIFO, j); F[j] += 1; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 26)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 26 not defined for 2D\n", F_NAME);
return(0);
}
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 26; k += 1)
{
j = voisin26(i, k, rs, ps, N);
if ((j != -1) && (F[j]==254)) { FifoPush(FIFO, j); F[j] += 1; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 60)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 6 not defined for 2D\n", F_NAME);
return(0);
}
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k <= 6; k += 2)
{
j = voisin6(i, k, rs, ps, N);
if ((j != -1) && (F[j]==254)) { FifoPush(FIFO, j); F[j] += 1; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 260)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 26 not defined for 2D\n", F_NAME);
return(0);
}
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 9; k <= 16; k += 1)
{
j = voisin26(i, k, rs, ps, N);
if ((j != -1) && (F[j]==254)) { FifoPush(FIFO, j); F[j] += 1; }
} /* for k */
} /* while ! FifoVide */
}
FifoTermine(FIFO);
for (i = 0; i < N; i++) if (F[i] != 255) F[i] = 0;
return 1;
} /* lselectcomp() */
/* ==================================== */
int32_t lsquel(struct xvimage *image, int32_t seuil, int32_t niseuil)
/* ==================================== */
{
int32_t x; /* index muet de pixel */
int32_t y; /* index muet (generalement un voisin de x) */
int32_t rs = rowsize(image); /* taille ligne */
int32_t cs = colsize(image); /* taille colonne */
int32_t N = rs * cs; /* taille image */
uint8_t *SOURCE = UCHARDATA(image); /* l'image de depart */
struct xvimage *lab;
int32_t *M; /* l'image d'etiquettes de composantes connexes */
int32_t nminima; /* nombre de minima differents */
Fifo * FIFOn;
Fifo * FIFOs;
Fifo * FIFOe;
Fifo * FIFOo;
Fifo * FIFOna;
Fifo * FIFOsa;
Fifo * FIFOea;
Fifo * FIFOoa;
Fifo * FIFOtmp;
Fifo * FIFO;
int32_t niter;
#ifdef PERF
chrono chrono1;
#endif
if (depth(image) != 1)
{
fprintf(stderr, "lsquel: cette version ne traite pas les images volumiques\n");
exit(0);
}
#ifdef PERF
start_chrono(&chrono1); /* pour l'analyse de performances */
#endif
lab = allocimage(NULL, rs, cs, 1, VFF_TYP_4_BYTE);
if (lab == NULL)
{
fprintf(stderr, "lhtkern: allocimage failed\n");
return 0;
}
M = SLONGDATA(lab);
if (!llabelextrema(image, 4, LABMIN, lab, &nminima))
{
fprintf(stderr, "lhtkern: llabelextrema failed\n");
return 0;
}
IndicsInit(N);
FIFO = CreeFifoVide(N);
FIFOn = CreeFifoVide(N/2);
FIFOs = CreeFifoVide(N/2);
FIFOe = CreeFifoVide(N/2);
FIFOo = CreeFifoVide(N/2);
if ((FIFO == NULL) && (FIFOn == NULL) && (FIFOs == NULL) && (FIFOe == NULL) && (FIFOo == NULL))
{ fprintf(stderr, "lsquel() : CreeFifoVide failed\n");
return(0);
}
/* ================================================ */
/* DEBUT ALGO */
/* ================================================ */
/* ========================================================= */
/* INITIALISATION DES FIFOs: empile les voisins des minima */
/* ========================================================= */
for (x = 0; x < N; x++)
{
if (M[x] != 0) /* le pixel appartient a un minimum */
{
Set(x, MINI);
y = voisin(x, NORD, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOn, y); Set(y, EN_FIFO); }
#ifdef DIAG
y = voisin(x, NORD+1, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOn, y); Set(y, EN_FIFO); }
#endif
y = voisin(x, EST, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOe, y); Set(y, EN_FIFO); }
#ifdef DIAG
y = voisin(x, EST+1, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOe, y); Set(y, EN_FIFO); }
#endif
y = voisin(x, SUD, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOs, y); Set(y, EN_FIFO); }
#ifdef DIAG
y = voisin(x, SUD+1, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOs, y); Set(y, EN_FIFO); }
#endif
y = voisin(x, OUEST, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOo, y); Set(y, EN_FIFO); }
#ifdef DIAG
y = voisin(x, OUEST+1, rs, N);
if ((y!=-1) && (M[y]==0) && !IsSet(y,EN_FIFO) && nonbord(y,rs,N))
{ FifoPush(FIFOo, y); Set(y, EN_FIFO); }
#endif
} /* if (M[x] != 0) */
} /* for x */
freeimage(lab);
FIFOna = CreeFifoVide(N/4);
FIFOsa = CreeFifoVide(N/4);
FIFOea = CreeFifoVide(N/4);
FIFOoa = CreeFifoVide(N/4);
if ((FIFOna == NULL) && (FIFOsa == NULL) && (FIFOea == NULL) && (FIFOoa == NULL))
{ fprintf(stderr, "lsquel() : CreeFifoVide failed\n");
return(0);
}
/* ================================================ */
/* DEBUT SATURATION */
/* ================================================ */
niter = 0;
while (! (FifoVide(FIFOn) && FifoVide(FIFOe) && FifoVide(FIFOs) && FifoVide(FIFOo)))
{
niter++;
while (! FifoVide(FIFOn))
{
x = FifoPop(FIFOn);
UnSet(x, EN_FIFO);
if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil))
{ /* modifie l'image le cas echeant */
testmini(SOURCE, x, rs, N, FIFO); /* reactualise l'image MINI */
empilevoisins(x, rs, N, FIFOna, FIFOea, FIFOsa, FIFOoa);
} /* if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil)) */
} /* while (! FifoVide(FIFOn)) */
while (! FifoVide(FIFOs))
{
x = FifoPop(FIFOs);
UnSet(x, EN_FIFO);
if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil))
{ /* modifie l'image le cas echeant */
testmini(SOURCE, x, rs, N, FIFO); /* reactualise l'image MINI */
empilevoisins(x, rs, N, FIFOna, FIFOea, FIFOsa, FIFOoa);
} /* if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil)) */
} /* while (! FifoVide(FIFOs)) */
while (! FifoVide(FIFOe))
{
x = FifoPop(FIFOe);
UnSet(x, EN_FIFO);
if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil))
{ /* modifie l'image le cas echeant */
testmini(SOURCE, x, rs, N, FIFO); /* reactualise l'image MINI */
empilevoisins(x, rs, N, FIFOna, FIFOea, FIFOsa, FIFOoa);
} /* if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil)) */
} /* while (! FifoVide(FIFOe)) */
while (! FifoVide(FIFOo))
{
x = FifoPop(FIFOo);
UnSet(x, EN_FIFO);
if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil))
{ /* modifie l'image le cas echeant */
testmini(SOURCE, x, rs, N, FIFO); /* reactualise l'image MINI */
empilevoisins(x, rs, N, FIFOna, FIFOea, FIFOsa, FIFOoa);
} /* if (testabaisse(SOURCE, x, rs, N, seuil, niter, niseuil)) */
} /* while (! FifoVide(FIFOo)) */
FIFOtmp = FIFOn; FIFOn = FIFOna; FIFOna = FIFOtmp;
FIFOtmp = FIFOe; FIFOe = FIFOea; FIFOea = FIFOtmp;
FIFOtmp = FIFOs; FIFOs = FIFOsa; FIFOsa = FIFOtmp;
FIFOtmp = FIFOo; FIFOo = FIFOoa; FIFOoa = FIFOtmp;
} /* while (! (FifoVide(FIFOn) && FifoVide(FIFOe) && FifoVide(FIFOs) && FifoVide(FIFOo))) */
/* ================================================ */
/* UN PEU DE MENAGE */
/* ================================================ */
IndicsTermine();
FifoTermine(FIFO);
FifoTermine(FIFOn);
FifoTermine(FIFOe);
FifoTermine(FIFOs);
FifoTermine(FIFOo);
FifoTermine(FIFOna);
FifoTermine(FIFOea);
FifoTermine(FIFOsa);
FifoTermine(FIFOoa);
#ifdef PERF
save_time(N, read_chrono(&chrono1), "lsquel", image->name);
#endif
return(1);
}
// As called from above
void SamplerTasks(void)
{
if ((status.streaming) && (settings.sampleRate != 0))
{
static char* start = NULL;
unsigned char conType;
#ifdef SAMPLE_LED
SAMPLE_LED=LED_TURN_ON;
#endif
// Grab a sample with cached sample time
currentSample.sampleCount = sampleCount;
currentSample.sampleTicks = sampleTicks;
// Read sensor values
MultiSingleSample(¤tSample.sensor);
// For BR connections -> put over serial link
conType = HciConType(bluetoothConnection);
if(conType == HCI_CONN_TYPE_BR)
{
// Convert to an outgoing data packet
unsigned short num = MakeDataPacket(¤tSample, settings.dataMode, (void*)&start);
// Ensure it was successful
if ((num == 0) || (start == NULL)) return;
// Try to copy to out buffer - if not enough room then skip this sample
if (FifoFree(&streamerFifo)>=num)
{
FifoPush(&streamerFifo, start, num);
status.newXdata = 0; // Indicate new extended data was sent
}
}
#ifndef DISABLE_LE_MODES
// For BLE connections -> indicate if turned on, overides notify
else if ((conType == HCI_CONN_TYPE_LE) && (dataOutHandle.dataFlag != 1) && (dataOutHandle.attCfg & ATT_CFG_INDICATE))
{
// Convert to an outgoing data packet
unsigned short num = MakeDataPacket(¤tSample, 2, (void*)&start); // 20 byte binary packet
// Ensure it was successful
if ((num == 0) || (start == NULL)) return;
dataOutHandle.dataFlag = 1;
dataOutHandle.attLen = num;
dataOutHandle.attData = (unsigned char*)start;
EventTrigger();
}
// For BLE connections -> notify if space and not already indicating
else if ((conType == HCI_CONN_TYPE_LE) && (dataOutHandle.dataFlag != 1) && (dataOutHandle.attCfg & ATT_CFG_NOTIFY))
{
// Convert to an outgoing data packet
unsigned short num = MakeDataPacket(¤tSample, 2, (void*)&start); // 20 byte binary packet
// Ensure it was successful
if ((num == 0) || (start == NULL)) return;
dataOutHandle.dataFlag = 1;
dataOutHandle.attLen = num;
dataOutHandle.attData = (unsigned char*)start;
EventTrigger();
}
#endif//ENABLE_LE_MODE
// On returning, if there is another sample triggered - this will be called again
}
}
/* ==================================== */
int32_t lgeoeros3d(
struct xvimage *g,
struct xvimage *f,
int32_t connex,
int32_t niter)
/* reconstruction de g sous f */
/* g : image marqueur */
/* f : image masque */
/* connex : 6 ou 18 ou 26 */
/* niter : nombre d'iterations (ou -1 pour saturation) */
/* resultat dans g */
/* ==================================== */
#undef F_NAME
#define F_NAME "lgeoeros3d"
{
int32_t nbchang, iter;
int32_t x; /* index muet de pixel */
int32_t y; /* index muet (generalement un voisin de x) */
int32_t k; /* index muet */
int32_t rs = rowsize(g); /* taille ligne */
int32_t cs = colsize(g); /* taille colonne */
int32_t d = depth(g); /* nombre plans */
int32_t n = rs * cs; /* taille plan */
int32_t N = n * d; /* taille image */
uint8_t *G = UCHARDATA(g); /* l'image marqueur */
uint8_t *F = UCHARDATA(f); /* l'image masque */
uint8_t *H; /* image de travail */
uint8_t *temp;
uint8_t inf;
Fifo * FIFO[2];
if ((rowsize(f) != rs) || (colsize(f) != cs) || (depth(f) != d))
{
fprintf(stderr, "%s: incompatible sizes\n", F_NAME);
return 0;
}
FIFO[0] = CreeFifoVide(N);
FIFO[1] = CreeFifoVide(N);
if ((FIFO[0] == NULL) || (FIFO[1] == NULL))
{ fprintf(stderr,"%s : CreeFifoVide failed\n", F_NAME);
return(0);
}
IndicsInit(N);
for (x = 0; x < N; x++) /* mise en fifo initiale de tous les points */ {
FifoPush(FIFO[1], x);
Set(x, 1);
}
H = (uint8_t *)calloc(1,N*sizeof(char));
if (H == NULL)
{ fprintf(stderr,"%s : malloc failed for H\n", F_NAME);
return(0);
}
for (x = 0; x < N; x++) /* force G à être >= F */
if (G[x] < F[x]) G[x] = F[x];
if (connex == 26)
{
iter = 0;
do
{
iter += 1;
nbchang = 0;
while (! FifoVide(FIFO[iter % 2]))
{
x = FifoPop(FIFO[iter % 2]);
UnSet(x, iter % 2);
inf = G[x];
for (k = 0; k < 26; k += 1)
{
y = voisin26(x, k, rs, n, N);
if ((y != -1) && (G[y] < inf)) inf = G[y];
} /* for k */
inf = mcmax(inf, F[x]);
if (G[x] != inf)
{ /* changement: on enregistre x ainsi que ses voisins */
nbchang += 1;
if (! IsSet(x, (iter + 1) % 2))
{
FifoPush(FIFO[(iter + 1) % 2], x);
Set(x, (iter + 1) % 2);
}
for (k = 0; k < 26; k += 1)
{
y = voisin26(x, k, rs, n, N);
if ((y != -1) && (! IsSet(y, (iter + 1) % 2)))
{
FifoPush(FIFO[(iter + 1) % 2], y);
Set(y, (iter + 1) % 2);
}
} /* for k */
}
H[x] = inf;
} /* while ! FifoVide */
temp = G; /* echange les roles de G et H */
G = H;
H = temp;
#ifdef VERBOSE
printf("iteration %d, nbchang %d\n", iter, nbchang);
#endif
} while (((niter == -1) || (iter < niter)) && (nbchang != 0));
}
else if (connex == 18)
{
iter = 0;
do
{
iter += 1;
nbchang = 0;
while (! FifoVide(FIFO[iter % 2]))
{
x = FifoPop(FIFO[iter % 2]);
UnSet(x, iter % 2);
inf = G[x];
for (k = 0; k < 18; k += 1)
{
y = voisin18(x, k, rs, n, N);
if ((y != -1) && (G[y] < inf)) inf = G[y];
} /* for k */
inf = mcmax(inf, F[x]);
if (G[x] != inf)
{ /* changement: on enregistre x ainsi que ses voisins */
nbchang += 1;
if (! IsSet(x, (iter + 1) % 2))
{
FifoPush(FIFO[(iter + 1) % 2], x);
Set(x, (iter + 1) % 2);
}
for (k = 0; k < 18; k += 1)
{
y = voisin18(x, k, rs, n, N);
if ((y != -1) && (! IsSet(y, (iter + 1) % 2)))
{
FifoPush(FIFO[(iter + 1) % 2], y);
Set(y, (iter + 1) % 2);
}
} /* for k */
}
H[x] = inf;
} /* while ! FifoVide */
temp = G; /* echange les roles de G et H */
G = H;
H = temp;
#ifdef VERBOSE
printf("iteration %d, nbchang %d\n", iter, nbchang);
#endif
} while (((niter == -1) || (iter < niter)) && (nbchang != 0));
}
else if (connex == 6)
{
iter = 0;
do
{
iter += 1;
nbchang = 0;
while (! FifoVide(FIFO[iter % 2]))
{
x = FifoPop(FIFO[iter % 2]);
UnSet(x, iter % 2);
inf = G[x];
for (k = 0; k <= 10; k += 2)
{
y = voisin6(x, k, rs, n, N);
if ((y != -1) && (G[y] < inf)) inf = G[y];
} /* for k */
inf = mcmax(inf, F[x]);
if (G[x] != inf)
{ /* changement: on enregistre x ainsi que ses voisins */
nbchang += 1;
if (! IsSet(x, (iter + 1) % 2))
{
FifoPush(FIFO[(iter + 1) % 2], x);
Set(x, (iter + 1) % 2);
}
for (k = 0; k <= 10; k += 2)
{
y = voisin6(x, k, rs, n, N);
if ((y != -1) && (! IsSet(y, (iter + 1) % 2)))
{
FifoPush(FIFO[(iter + 1) % 2], y);
Set(y, (iter + 1) % 2);
}
} /* for k */
}
H[x] = inf;
} /* while ! FifoVide */
temp = G; /* echange les roles de G et H */
G = H;
H = temp;
#ifdef VERBOSE
printf("iteration %d, nbchang %d\n", iter, nbchang);
#endif
} while (((niter == -1) || (iter < niter)) && (nbchang != 0));
}
else
{
fprintf(stderr, "%s: bad connexity\n", F_NAME);
return 0;
}
/* remet le resultat dans g si necessaire */
if (G != UCHARDATA(g))
{
for (x = 0; x < N; x++)
(UCHARDATA(g))[x] = G[x];
free(G);
}
else
free(H);
FifoTermine(FIFO[0]);
FifoTermine(FIFO[1]);
IndicsTermine();
return 1;
} // lgeoeros3d(
/* ==================================== */
int32_t lgeodilat(
struct xvimage *g,
struct xvimage *f,
int32_t connex,
int32_t niter)
/* dilatation geodesique de g sous f */
/* g : image marqueur */
/* f : image masque */
/* connex : 4 ou 8 */
/* niter : nombre d'iterations (ou -1 pour saturation) */
/* resultat dans g */
/* ==================================== */
#undef F_NAME
#define F_NAME "lgeodilat"
{
int32_t nbchang, iter;
int32_t x; /* index muet de pixel */
int32_t y; /* index muet (generalement un voisin de x) */
int32_t k; /* index muet */
int32_t rs = rowsize(g); /* taille ligne */
int32_t cs = colsize(g); /* taille colonne */
int32_t N = rs * cs; /* taille image */
uint8_t *G = UCHARDATA(g); /* l'image marqueur */
uint8_t *F = UCHARDATA(f); /* l'image masque */
uint8_t *H; /* image de travail */
uint8_t *temp;
uint8_t sup;
Fifo * FIFO[2];
int32_t incr_vois;
switch (connex)
{
case 4: incr_vois = 2; break;
case 8: incr_vois = 1; break;
} /* switch (connex) */
if ((rowsize(f) != rs) || (colsize(f) != cs))
{
fprintf(stderr, "%s: incompatible sizes\n", F_NAME);
return 0;
}
if (depth(f) != 1)
{
fprintf(stderr, "%s: only works for 2d images\n", F_NAME);
return 0;
}
FIFO[0] = CreeFifoVide(N);
FIFO[1] = CreeFifoVide(N);
if ((FIFO[0] == NULL) || (FIFO[1] == NULL))
{ fprintf(stderr,"%s : CreeFifoVide failed\n", F_NAME);
return(0);
}
IndicsInit(N);
for (x = 0; x < N; x++) /* mise en fifo initiale de tous les points */
{
FifoPush(FIFO[1], x);
Set(x, 1);
}
H = (uint8_t *)calloc(1,N*sizeof(char));
if (H == NULL)
{ fprintf(stderr,"%s : malloc failed for H\n", F_NAME);
return(0);
}
for (x = 0; x < N; x++) /* force G à être <= F */
if (G[x] > F[x]) G[x] = F[x];
iter = 0;
do
{
iter += 1;
nbchang = 0;
while (! FifoVide(FIFO[iter % 2]))
{
x = FifoPop(FIFO[iter % 2]);
UnSet(x, iter % 2);
sup = G[x];
for (k = 0; k < 8; k += incr_vois)
{
y = voisin(x, k, rs, N);
if ((y != -1) && (G[y] > sup)) sup = G[y];
} /* for k */
sup = mcmin(sup, F[x]);
if (G[x] != sup) /* changement: on enregistre x ainsi que ses voisins */
{
nbchang += 1;
if (! IsSet(x, (iter + 1) % 2))
{
FifoPush(FIFO[(iter + 1) % 2], x);
Set(x, (iter + 1) % 2);
}
for (k = 0; k < 8; k += 1)
{
y = voisin(x, k, rs, N);
if ((y != -1) && (! IsSet(y, (iter + 1) % 2)))
{
FifoPush(FIFO[(iter + 1) % 2], y);
Set(y, (iter + 1) % 2);
}
} /* for k */
}
H[x] = sup;
} /* while ! FifoVide */
/* echange les roles de G et H */
temp = G;
G = H;
H = temp;
#ifdef VERBOSE
printf("iteration %d, nbchang %d\n", iter, nbchang);
#endif
} while (((niter == -1) || (iter < niter)) && (nbchang != 0));
/* remet le resultat dans g si necessaire */
if (G != UCHARDATA(g))
{
for (x = 0; x < N; x++)
(UCHARDATA(g))[x] = G[x];
free(G);
}
else
free(H);
FifoTermine(FIFO[0]);
FifoTermine(FIFO[1]);
IndicsTermine();
return 1;
} /* lgeodilat() */
/* ==================================== */
int32_t lamont(
struct xvimage *m,
struct xvimage *f,
int32_t connex,
int32_t strict)
/* connex : 4, 8 (en 2D), 6, 18, 26 (en 3D) */
/* ==================================== */
#undef F_NAME
#define F_NAME "lamont"
{
int32_t i, j, k; /* index muet de pixel */
int32_t rs = rowsize(f); /* taille ligne */
int32_t cs = colsize(f); /* taille colonne */
int32_t ds = depth(f); /* nb plans */
int32_t ps = rs * cs; /* taille plan */
int32_t N = ps * ds; /* taille image */
int32_t *F = SLONGDATA(f);
uint8_t *M = UCHARDATA(m);
Fifo * FIFO;
int32_t incr_vois;
if ((rowsize(m) != rs) || (colsize(m) != cs) || (depth(m) != ds))
{
fprintf(stderr, "%s: incompatible sizes\n", F_NAME);
return 0;
}
if ((datatype(m) != VFF_TYP_1_BYTE) || (datatype(f) != VFF_TYP_4_BYTE))
{
fprintf(stderr, "%s: incompatible types\n", F_NAME);
return 0;
}
switch (connex)
{
case 4: incr_vois = 2; break;
case 8: incr_vois = 1; break;
} /* switch (connex) */
FIFO = CreeFifoVide(N);
if (FIFO == NULL)
{ fprintf(stderr,"%s : CreeFifoVide failed\n", F_NAME);
return(0);
}
for (i = 0; i < N; i++) if (M[i]) FifoPush(FIFO, i);
if ((connex == 4) || (connex == 8))
{
if (ds != 1)
{
fprintf(stderr,"%s : connexity 4 or 8 not defined for 3D\n", F_NAME);
return(0);
}
if (strict)
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 8; k += incr_vois)
{
j = voisin(i, k, rs, N);
if ((j != -1) && !M[j] && (F[j] > F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
else
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 8; k += incr_vois)
{
j = voisin(i, k, rs, N);
//printf("i=%d ; j=%d ; Mj=%d ; Fj=%ld ; Fi=%ld\n", i, j, M[j], F[j], F[i]);
if ((j != -1) && !M[j] && (F[j] >= F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 6)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 6 not defined for 2D\n", F_NAME);
return(0);
}
if (strict)
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k <= 10; k += 2)
{
j = voisin6(i, k, rs, ps, N);
if ((j != -1) && !M[j] && (F[j] > F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
else
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k <= 10; k += 2)
{
j = voisin6(i, k, rs, ps, N);
if ((j != -1) && !M[j] && (F[j] >= F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 18)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 18 not defined for 2D\n", F_NAME);
return(0);
}
if (strict)
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 18; k += 1)
{
j = voisin18(i, k, rs, ps, N);
if ((j != -1) && !M[j] && (F[j] > F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
else
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 18; k += 1)
{
j = voisin18(i, k, rs, ps, N);
if ((j != -1) && !M[j] && (F[j] >= F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
}
else if (connex == 26)
{
if (ds == 1)
{ fprintf(stderr,"%s : connexity 26 not defined for 2D\n", F_NAME);
return(0);
}
if (strict)
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 26; k += 1)
{
j = voisin26(i, k, rs, ps, N);
if ((j != -1) && !M[j] && (F[j] > F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
else
while (! FifoVide(FIFO))
{
i = FifoPop(FIFO);
for (k = 0; k < 26; k += 1)
{
j = voisin26(i, k, rs, ps, N);
if ((j != -1) && !M[j] && (F[j] >= F[i])) { FifoPush(FIFO, j); M[j] = 255; }
} /* for k */
} /* while ! FifoVide */
}
FifoTermine(FIFO);
return 1;
} /* lamont() */
