void VLCControlsWnd::SyncVideoPosScrollPosWithVideoPos()
{
if( VP() ){
libvlc_time_t pos = VP()->get_time();
SetVideoPosScrollPosByVideoPos(pos);
}
}
void VLCHolderWnd::LibVlcDetach()
{
if( VP() )
libvlc_media_player_set_hwnd( VP()->get_mp(), 0);
MouseHook( false );
}
void ProcessesLocal::Private::readProcStat(struct kinfo_proc *p, Process *ps)
{
ps->setUserTime(LP(p, uticks) / 10000);
ps->setSysTime((LP(p, sticks) + LP(p, iticks)) / 10000);
ps->setNiceLevel(PP(p, nice));
ps->setVmSize(VP(p, map_size) / 1024); /* convert to KiB */
ps->setVmRSS(VP(p, prssize) * getpagesize() / 1024); /* convert to KiB */
// "idle","run","sleep","stop","zombie"
switch( LP(p, stat) ) {
case LSRUN:
ps->setStatus(Process::Running);
break;
case LSSLEEP:
ps->setStatus(Process::Sleeping);
break;
case LSSTOP:
ps->setStatus(Process::Stopped);
break;
default:
ps->setStatus(Process::OtherStatus);
break;
}
if (PP(p, stat) == SZOMB)
ps->setStatus(Process::Zombie);
}
void fusion(objet *t,int d,int m,int f)
{
int i1=d,i2=m+1,i3=0;
objet *temp=(objet *)malloc((f-d+1)*sizeof(objet));
while((i1<=m)&&(i2<=f))
{
if(VP(t[i1])<= VP(t[i2]))
{
temp[i3]=t[i1];
i1++;
}
else
{
temp[i3]=t[i2];
i2++;
}
i3++;
}
for(;i2<f;i2++,i3++)
temp[i3]=t[i2];
for(;i1<m;i1++,i3++)
temp[i3]=t[i1];
for(i1=0;i1<i3;i1++)
t[i1+d]=temp[i1];
}
void MatrixMultT(Matrix*mtD,Matrix*mtA,Matrix*mtB){
// D = A B^T
int i,j;
for(i=0;i<mtA->H;i++)
for(j=0;j<mtB->H;j++)
Elem(mtD,i,j) = VP( Row(mtA,i), Row(mtB,j), mtA->W);
}
void MatrixQRDecompColMajor(Matrix*mtR,Matrix*mt){
// gram-schmidt orthonormalization (Lt and Q)
double t, *aT[mt->W];
int W = mt->W;
int i,j;
MatrixClear(mtR);
for (i = 0; i < W;i++) {
aT[i] = Row(mt,i);
for (j = 0; j < i; j++) {
Elem(mtR,j,i) = t = VP(aT[j], aT[i], W);
VSA(aT[i], aT[j], -t, W);
}
Elem(mtR,i,i) = t = sqrt(VP(aT[i],aT[i],W));
VSS(aT[i], 1/t, W);
}
/*
Elem(mtR,0,0) = t = sqrt(VP(aT[0],aT[0],W));
VSS(aT[0], 1/t, W);
Elem(mtR,0,1) = t = VP(aT[0], aT[1], W);
VSA(aT[1], aT[0], -t, W);
Elem(mtR,1,1) = t = sqrt(VP(aT[1],aT[1],W));
VSS(aT[1], 1/t, W);
///////////
Elem(mtR,0,2) = t = VP(aT[0], aT[2], W);
VSA(aT[2], aT[0], -t, W);
Elem(mtR,1,2) = t = VP(aT[1], aT[2], W);
VSA(aT[2], aT[1], -t, W);
Elem(mtR,2,2) = t = sqrt(VP(aT[2],aT[2],W));
VSS(aT[2], 1/t, W);
////// 以下略
*/
}
CoordBox NativeRenderDialog::boundingBox()
{
CoordBox VP(Coord(
ui.sbMinLon->value(),
ui.sbMinLat->value()
), Coord(
ui.sbMaxLon->value(),
ui.sbMaxLat->value()
));
return VP;
}
void VLCWindowsManager::VlcEvents( bool Attach )
{
if( !VP() )
return;
vlc_player& vp = *VP();
libvlc_event_manager_t* em =
libvlc_media_player_event_manager( vp.get_mp() );
if( !em )
return;
for( int e = libvlc_MediaPlayerMediaChanged; e <= libvlc_MediaPlayerVout; ++e ) {
switch( e ) {
//case libvlc_MediaPlayerMediaChanged:
//case libvlc_MediaPlayerNothingSpecial:
//case libvlc_MediaPlayerOpening:
//case libvlc_MediaPlayerBuffering:
case libvlc_MediaPlayerPlaying:
//case libvlc_MediaPlayerPaused:
//case libvlc_MediaPlayerStopped:
//case libvlc_MediaPlayerForward:
//case libvlc_MediaPlayerBackward:
//case libvlc_MediaPlayerEndReached:
//case libvlc_MediaPlayerEncounteredError:
//case libvlc_MediaPlayerTimeChanged:
case libvlc_MediaPlayerPositionChanged:
//case libvlc_MediaPlayerSeekableChanged:
//case libvlc_MediaPlayerPausableChanged:
//case libvlc_MediaPlayerTitleChanged:
//case libvlc_MediaPlayerSnapshotTaken:
//case libvlc_MediaPlayerLengthChanged:
//case libvlc_MediaPlayerVout:
if( Attach )
libvlc_event_attach( em, e, OnLibVlcEvent_proxy, this );
else
libvlc_event_detach( em, e, OnLibVlcEvent_proxy, this );
break;
}
}
}
void VLCControlsWnd::SetVideoPosScrollRangeByVideoLen()
{
if( VP() ){
libvlc_time_t MaxLen = VP()->get_length();
VideoPosShiftBits = 0;
while(MaxLen>0xffff){
MaxLen >>= 1;
++VideoPosShiftBits;
};
SendMessage(hVideoPosScroll, (UINT)PBM_SETRANGE, 0, MAKELPARAM(0, MaxLen));
}
}
void VLCWindowsManager::StartFullScreen()
{
if( !_HolderWnd || ( PO() && !PO()->get_enable_fs() ) )
return; //VLCWindowsManager::CreateWindows was not called
if( VP() && !IsFullScreen() ) {
if( !_FSWnd ) {
_FSWnd= VLCFullScreenWnd::CreateFSWindow( this );
}
RECT FSRect = { 0, 0, GetSystemMetrics( SM_CXSCREEN ), GetSystemMetrics( SM_CYSCREEN ) };
HMONITOR hMonitor = MonitorFromWindow( _hWindowedParentWnd, MONITOR_DEFAULTTONEAREST );
MONITORINFO MonInfo;
memset( &MonInfo, 0, sizeof( MonInfo ) );
MonInfo.cbSize = sizeof( MonInfo );
if( GetMonitorInfo( hMonitor, &MonInfo ) ) {
FSRect = MonInfo.rcMonitor;
}
#ifdef _DEBUG
//to simplify debugging in fullscreen mode
UINT FSFlags = SWP_NOZORDER;
#else
UINT FSFlags = 0;
#endif
SetParent( _HolderWnd->hWnd(), _FSWnd->getHWND() );
SetWindowPos( _FSWnd->getHWND(), HWND_TOPMOST,
FSRect.left, FSRect.top,
FSRect.right - FSRect.left, FSRect.bottom - FSRect.top,
FSFlags );
ShowWindow( _FSWnd->getHWND(), SW_SHOW );
}
}
LRESULT VLCControlsWnd::WindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg){
case WM_CREATE:{
const int ControlsHeight = 21+3;
const int ButtonsWidth = ControlsHeight;
int HorizontalOffset = xControlsSpace;
int ControlWidth = ButtonsWidth;
hPlayPauseButton =
CreateWindow(TEXT("BUTTON"), TEXT("Play/Pause"),
WS_CHILD|WS_VISIBLE|BS_BITMAP|BS_FLAT,
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight, hWnd(),
(HMENU)ID_FS_PLAY_PAUSE, 0, 0);
SendMessage(hPlayPauseButton, BM_SETIMAGE,
(WPARAM)IMAGE_BITMAP, (LPARAM)RC().hPauseBitmap);
HorizontalOffset+=ControlWidth+xControlsSpace;
ControlWidth = 200;
int VideoPosControlHeight = 10;
hVideoPosScroll =
CreateWindow(PROGRESS_CLASS, TEXT("Video Position"),
WS_CHILD|WS_DISABLED|WS_VISIBLE|SBS_HORZ|SBS_TOPALIGN|PBS_SMOOTH,
HorizontalOffset, xControlsSpace+(ControlsHeight-VideoPosControlHeight)/2,
ControlWidth, VideoPosControlHeight, hWnd(),
(HMENU)ID_FS_VIDEO_POS_SCROLL, 0, 0);
HMODULE hThModule = LoadLibrary(TEXT("UxTheme.dll"));
if(hThModule){
FARPROC proc = GetProcAddress(hThModule, "SetWindowTheme");
typedef HRESULT (WINAPI* SetWindowThemeProc)(HWND, LPCWSTR, LPCWSTR);
if(proc){
((SetWindowThemeProc)proc)(hVideoPosScroll, L"", L"");
}
FreeLibrary(hThModule);
}
HorizontalOffset+=ControlWidth+xControlsSpace;
ControlWidth = ButtonsWidth;
hMuteButton =
CreateWindow(TEXT("BUTTON"), TEXT("Mute"),
WS_CHILD|WS_VISIBLE|BS_AUTOCHECKBOX|BS_PUSHLIKE|BS_BITMAP, //BS_FLAT
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight,
hWnd(), (HMENU)ID_FS_MUTE, 0, 0);
SendMessage(hMuteButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP,
(LPARAM)RC().hVolumeBitmap);
HorizontalOffset+=ControlWidth+xControlsSpace;
ControlWidth = 100;
hVolumeSlider =
CreateWindow(TRACKBAR_CLASS, TEXT("Volume"),
WS_CHILD|WS_VISIBLE|TBS_HORZ|TBS_BOTTOM|TBS_AUTOTICKS,
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight - 4, hWnd(),
(HMENU)ID_FS_VOLUME, 0, 0);
HorizontalOffset+=ControlWidth+xControlsSpace;
SendMessage(hVolumeSlider, TBM_SETRANGE, FALSE, (LPARAM) MAKELONG (0, 100));
SendMessage(hVolumeSlider, TBM_SETTICFREQ, (WPARAM) 10, 0);
ControlWidth = ButtonsWidth;
DWORD dwFSBtnStyle = WS_CHILD|BS_BITMAP|BS_FLAT;
if( !PO() || PO()->get_enable_fs() ){
dwFSBtnStyle |= WS_VISIBLE;
}
hFSButton =
CreateWindow(TEXT("BUTTON"), TEXT("Toggle fullscreen"),
dwFSBtnStyle,
HorizontalOffset, xControlsSpace,
ControlWidth, ControlsHeight, hWnd(),
(HMENU)ID_FS_SWITCH_FS, 0, 0);
SendMessage(hFSButton, BM_SETIMAGE, (WPARAM)IMAGE_BITMAP,
(LPARAM)RC().hDeFullscreenBitmap);
HorizontalOffset+=ControlWidth+xControlsSpace;
RECT rect;
GetClientRect(GetParent(hWnd()), &rect);
int ControlWndWidth = HorizontalOffset;
int ControlWndHeight = xControlsSpace+ControlsHeight+xControlsSpace;
SetWindowPos(hWnd(), 0,
0, (rect.bottom - rect.top) - ControlWndWidth,
rect.right-rect.left, ControlWndHeight,
SWP_NOZORDER|SWP_NOOWNERZORDER|SWP_NOACTIVATE);
//new message blinking timer
SetTimer(hWnd(), 2, 500, NULL);
CreateToolTip();
break;
}
case WM_SHOWWINDOW:{
if(FALSE!=wParam){ //showing
UpdateButtons();
}
break;
}
case WM_LBUTTONUP:{
POINT BtnUpPoint = {LOWORD(lParam), HIWORD(lParam)};
RECT VideoPosRect;
GetWindowRect(hVideoPosScroll, &VideoPosRect);
ClientToScreen(hWnd(), &BtnUpPoint);
if(PtInRect(&VideoPosRect, BtnUpPoint)){
SetVideoPos(float(BtnUpPoint.x-VideoPosRect.left)/(VideoPosRect.right-VideoPosRect.left));
}
break;
}
case WM_TIMER:{
switch(wParam){
case 1:{
POINT MousePoint;
GetCursorPos(&MousePoint);
RECT ControlWndRect;
GetWindowRect(hWnd(), &ControlWndRect);
if(PtInRect(&ControlWndRect, MousePoint)||GetCapture()==hVolumeSlider){
//do not allow control window to close while mouse is within
NeedShowControls();
}
else{
NeedHideControls();
}
break;
}
case 2:{
UpdateButtons();
break;
}
}
break;
}
case WM_SETCURSOR:{
RECT VideoPosRect;
GetWindowRect(hVideoPosScroll, &VideoPosRect);
DWORD dwMsgPos = GetMessagePos();
POINT MsgPosPoint = {LOWORD(dwMsgPos), HIWORD(dwMsgPos)};
if(PtInRect(&VideoPosRect, MsgPosPoint)){
SetCursor(LoadCursor(NULL, IDC_HAND));
return TRUE;
}
else{
return VLCWnd::WindowProc(uMsg, wParam, lParam);
}
break;
}
case WM_NCDESTROY:
break;
case WM_COMMAND:{
WORD NCode = HIWORD(wParam);
WORD Control = LOWORD(wParam);
switch(NCode){
case BN_CLICKED:{
switch(Control){
case ID_FS_SWITCH_FS:
WM().ToggleFullScreen();
break;
case ID_FS_PLAY_PAUSE:{
if( VP() ){
if( IsPlaying() )
VP()->pause();
else
VP()->play();
}
break;
}
case ID_FS_MUTE:{
if( VP() ){
VP()->audio().set_mute( IsDlgButtonChecked(hWnd(), ID_FS_MUTE) != FALSE );
SyncVolumeSliderWithVLCVolume();
}
break;
}
}
break;
}
}
break;
}
case WM_SIZE:{
if( (GetWindowLong(hWnd(), GWL_STYLE) & WS_VISIBLE) &&
( !PO() ||
( !WM().IsFullScreen() && !PO()->get_show_toolbar() ) ||
( WM().IsFullScreen() && !PO()->get_show_fs_toolbar() ) ) )
{
//hide controls when they are not allowed
NeedHideControls();
}
const int new_client_width = LOWORD(lParam);
bool isFSBtnVisible =
(GetWindowLong(hFSButton, GWL_STYLE) & WS_VISIBLE) != 0;
HDWP hDwp = BeginDeferWindowPos(4);
int VideoScrollWidth = new_client_width;
POINT pt = {0, 0};
RECT rect;
GetWindowRect(hPlayPauseButton, &rect);
pt.x = rect.right;
ScreenToClient(hWnd(), &pt);
VideoScrollWidth -= pt.x;
VideoScrollWidth -= xControlsSpace;
RECT VideoSrcollRect;
GetWindowRect(hVideoPosScroll, &VideoSrcollRect);
RECT MuteRect;
GetWindowRect(hMuteButton, &MuteRect);
VideoScrollWidth -= xControlsSpace;
VideoScrollWidth -= (MuteRect.right - MuteRect.left);
RECT VolumeRect;
GetWindowRect(hVolumeSlider, &VolumeRect);
VideoScrollWidth -= xControlsSpace;
VideoScrollWidth -= (VolumeRect.right - VolumeRect.left);
RECT FSRect = {0, 0, 0, 0};
if( isFSBtnVisible ) {
GetWindowRect(hFSButton, &FSRect);
VideoScrollWidth -= xControlsSpace;
VideoScrollWidth -= (FSRect.right - FSRect.left);
VideoScrollWidth -= xControlsSpace;
}
pt.x = VideoSrcollRect.left;
pt.y = VideoSrcollRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hVideoPosScroll, 0, pt.x, pt.y,
VideoScrollWidth,
VideoSrcollRect.bottom - VideoSrcollRect.top,
SWP_NOACTIVATE|SWP_NOOWNERZORDER);
int HorizontalOffset =
pt.x + VideoScrollWidth + xControlsSpace;
pt.x = 0;
pt.y = MuteRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hMuteButton, 0,
HorizontalOffset, pt.y, 0, 0,
SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
HorizontalOffset +=
MuteRect.right - MuteRect.left + xControlsSpace;
pt.x = 0;
pt.y = VolumeRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hVolumeSlider, 0,
HorizontalOffset, pt.y, 0, 0,
SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
HorizontalOffset +=
VolumeRect.right - VolumeRect.left + xControlsSpace;
if( isFSBtnVisible ) {
pt.x = 0;
pt.y = FSRect.top;
ScreenToClient(hWnd(), &pt);
hDwp = DeferWindowPos(hDwp, hFSButton, 0,
HorizontalOffset, pt.y, 0, 0,
SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOOWNERZORDER);
}
EndDeferWindowPos(hDwp);
break;
}
case WM_HSCROLL:
case WM_VSCROLL: {
if( VP() ){
if(hVolumeSlider==(HWND)lParam){
LRESULT SliderPos = SendMessage(hVolumeSlider, (UINT) TBM_GETPOS, 0, 0);
SetVLCVolumeBySliderPos(SliderPos);
}
}
break;
}
default:
return VLCWnd::WindowProc(uMsg, wParam, lParam);
}
return 0L;
}
void CMineView::InterpModelData(UINT8 *p)
{
assert(p);
assert(gModel.polys);
while (W(p) != OP_EOF) {
switch (W(p)) {
// Point Definitions with Start Offset:
// 2 UINT16 n_points number of points
// 4 UINT16 start_point starting point
// 6 UINT16 unknown
// 8 VMS_VECTOR pts[n_points] x,y,z data
case OP_DEFP_START: {
pt0 = W(p+4);
n_points = W(p+2);
gModel.n_points += n_points;
assert(W(p+6)==0);
assert(gModel.n_points < MAX_POLY_MODEL_POINTS);
assert(pt0+n_points < MAX_POLY_MODEL_POINTS);
for (pt=0;pt< n_points;pt++) {
gModel.points[pt+pt0].x = VP(p+8)[pt].x + gOffset.x;
gModel.points[pt+pt0].y = VP(p+8)[pt].y + gOffset.y;
gModel.points[pt+pt0].z = VP(p+8)[pt].z + gOffset.z;
}
SetModelPoints(pt0,pt0+n_points);
p += W(p+2)*sizeof(VMS_VECTOR) + 8;
break;
}
// Flat Shaded Polygon:
// 2 UINT16 n_verts
// 4 VMS_VECTOR vector1
// 16 VMS_VECTOR vector2
// 28 UINT16 color
// 30 UINT16 verts[n_verts]
case OP_FLATPOLY: {
panel = &gModel.polys[gModel.n_polys];
panel->n_verts = W(p+2);
panel->offset = *VP(p+4);
panel->normal = *VP(p+16);
for (pt=0;pt<panel->n_verts;pt++) {
panel->verts[pt] = WP(p+30)[pt];
}
assert(panel->n_verts>=MIN_POLY_POINTS);
assert(panel->n_verts<=MAX_POLY_POINTS);
assert(gModel.n_polys < MAX_POLYS);
DrawPoly(panel);
p += 30 + ((panel->n_verts&~1)+1)*2;
break;
}
// Texture Mapped Polygon:
// 2 UINT16 n_verts
// 4 VMS_VECTOR vector1
// 16 VMS_VECTOR vector2
// 28 UINT16 nBaseTex
// 30 UINT16 verts[n_verts]
// -- UVL uvls[n_verts]
case OP_TMAPPOLY: {
panel = &gModel.polys[gModel.n_polys];
panel->n_verts = W(p+2);
assert(panel->n_verts>=MIN_POLY_POINTS);
assert(panel->n_verts<=MAX_POLY_POINTS);
assert(gModel.n_polys < MAX_POLYS);
panel->offset = *VP(p+4);
panel->normal = *VP(p+16);
panel->color = -1;
panel->nBaseTex = W(p+28);
panel->glow_num = glow_num;
for (pt=0;pt<panel->n_verts;pt++) {
panel->verts[pt] = WP(p+30)[pt];
}
p += 30 + ((panel->n_verts&~1)+1)*2;
DrawPoly(panel);
p += panel->n_verts * 12;
break;
}
// Sort by Normal
// 2 UINT16 unknown
// 4 VMS_VECTOR Front Model normal
// 16 VMS_VECTOR Back Model normal
// 28 UINT16 Front Model Offset
// 30 UINT16 Back Model Offset
case OP_SORTNORM: {
/* = W(p+2); */
/* = W(p+4); */
/* = W(p+16); */
assert(W(p+2)==0);
assert(W(p+28)>0);
assert(W(p+30)>0);
if ( m_matrix.CheckNormal(gpObject, VP(p+4),VP(p+16)) ) {
InterpModelData(p + W(p+28));
InterpModelData(p + W(p+30));
} else {
InterpModelData(p + W(p+30));
InterpModelData(p + W(p+28));
}
p += 32;
break;
}
// Call a Sub Object
// 2 UINT16 n_anims
// 4 VMS_VECTOR offset
// 16 UINT16 model offset
case OP_SUBCALL: {
assert(W(p+16)>0);
/* = VP(p+4) */
gOffset.x += VP(p+4)->x;
gOffset.y += VP(p+4)->y;
gOffset.z += VP(p+4)->z;
InterpModelData(p + W(p+16));
gOffset.x -= VP(p+4)->x;
gOffset.y -= VP(p+4)->y;
gOffset.z -= VP(p+4)->z;
p += 20;
break;
}
// Glow Number for Next Poly
// 2 UINTW Glow_Value
case OP_GLOW: {
glow_num = W(p+2);
p += 4;
break;
}
default: {
assert(0);
}
}
}
return;
}
void Jacobi(const SymmetricMatrix& X, DiagonalMatrix& D, SymmetricMatrix& A,
Matrix& V, bool eivec)
{
Real epsilon = FloatingPointPrecision::Epsilon();
Tracer et("Jacobi");
REPORT
int n = X.Nrows(); DiagonalMatrix B(n), Z(n); D.resize(n); A = X;
if (eivec) { REPORT V.resize(n,n); D = 1.0; V = D; }
B << A; D = B; Z = 0.0; A.Inject(Z);
bool converged = false;
for (int i=1; i<=50; i++)
{
Real sm=0.0; Real* a = A.Store(); int p = A.Storage();
while (p--) sm += fabs(*a++); // have previously zeroed diags
if (sm==0.0) { REPORT converged = true; break; }
Real tresh = (i<4) ? 0.2 * sm / square(n) : 0.0; a = A.Store();
for (p = 0; p < n; p++)
{
Real* ap1 = a + (p*(p+1))/2;
Real& zp = Z.element(p); Real& dp = D.element(p);
for (int q = p+1; q < n; q++)
{
Real* ap = ap1; Real* aq = a + (q*(q+1))/2;
Real& zq = Z.element(q); Real& dq = D.element(q);
Real& apq = A.element(q,p);
Real g = 100 * fabs(apq); Real adp = fabs(dp); Real adq = fabs(dq);
if (i>4 && g < epsilon*adp && g < epsilon*adq) { REPORT apq = 0.0; }
else if (fabs(apq) > tresh)
{
REPORT
Real t; Real h = dq - dp; Real ah = fabs(h);
if (g < epsilon*ah) { REPORT t = apq / h; }
else
{
REPORT
Real theta = 0.5 * h / apq;
t = 1.0 / ( fabs(theta) + sqrt(1.0 + square(theta)) );
if (theta<0.0) { REPORT t = -t; }
}
Real c = 1.0 / sqrt(1.0 + square(t)); Real s = t * c;
Real tau = s / (1.0 + c); h = t * apq;
zp -= h; zq += h; dp -= h; dq += h; apq = 0.0;
int j = p;
while (j--)
{
g = *ap; h = *aq;
*ap++ = g-s*(h+g*tau); *aq++ = h+s*(g-h*tau);
}
int ip = p+1; j = q-ip; ap += ip++; aq++;
while (j--)
{
g = *ap; h = *aq;
*ap = g-s*(h+g*tau); *aq++ = h+s*(g-h*tau);
ap += ip++;
}
if (q < n-1) // last loop is non-empty
{
int iq = q+1; j = n-iq; ap += ip++; aq += iq++;
for (;;)
{
g = *ap; h = *aq;
*ap = g-s*(h+g*tau); *aq = h+s*(g-h*tau);
if (!(--j)) break;
ap += ip++; aq += iq++;
}
}
if (eivec)
{
REPORT
RectMatrixCol VP(V,p); RectMatrixCol VQ(V,q);
Rotate(VP, VQ, tau, s);
}
}
}
}
B = B + Z; D = B; Z = 0.0;
}
if (!converged) Throw(ConvergenceException(X));
if (eivec) SortSV(D, V, true);
else SortAscending(D);
}
void gmm_fisher_save_soft_assgn(int n, const float *v, const gmm_t * g, int flags,
float *dp_dlambda,
float *word_total_soft_assignment) {
long d=g->d, k=g->k;
float *p = fvec_new(n * k);
long i,j,l;
long ii=0;
float * vp = NULL; /* v*p */
float * sum_pj = NULL; /* sum of p's for a given j */
gmm_compute_p(n,v,g,p,flags | GMM_FLAGS_W);
#define P(j,i) p[(i)*k+(j)]
#define V(l,i) v[(i)*d+(l)]
#define MU(l,j) g->mu[(j)*d+(l)]
#define SIGMA(l,j) g->sigma[(j)*d+(l)]
#define VP(l,j) vp[(j)*d+(l)]
// Save total soft assignment per centroid
if (word_total_soft_assignment != NULL) {
for (j=0; j<k; j++) {
double sum=0;
for (i=0; i<n; i++) {
sum += P(j,i);
}
if (n != 0) {
word_total_soft_assignment[j] = (float)(sum/n);
} else {
word_total_soft_assignment[j] = 0.0;
}
}
}
if(flags & GMM_FLAGS_W) {
for(j=1; j<k; j++) {
double accu=0;
for(i=0; i<n; i++)
accu+= P(j,i)/g->w[j] - P(0,i)/g->w[0];
/* normalization */
double f=n*(1/g->w[j]+1/g->w[0]);
dp_dlambda[ii++]=accu/sqrt(f);
}
}
if(flags & GMM_FLAGS_MU) {
float *dp_dmu=dp_dlambda+ii;
#define DP_DMU(l,j) dp_dmu[(j)*d+(l)]
if(0) { /* simple and slow */
for(j=0; j<k; j++) {
for(l=0; l<d; l++) {
double accu=0;
for(i=0; i<n; i++)
accu += P(j,i) * (V(l,i)-MU(l,j)) / SIGMA(l,j);
DP_DMU(l,j)=accu;
}
}
} else { /* complicated and fast */
/* precompute tables that may be useful for sigma too */
vp = fvec_new(k * d);
fmat_mul_tr(v,p,d,k,n,vp);
sum_pj = fvec_new(k);
for(j=0; j<k; j++) {
double sum=0;
for(i=0; i<n; i++) sum += P(j,i);
sum_pj[j] = sum;
}
for(j=0; j<k; j++) {
for(l=0; l<d; l++)
DP_DMU(l,j) = (VP(l,j) - MU(l,j) * sum_pj[j]) / SIGMA(l,j);
}
}
/* normalization */
if(!(flags & GMM_FLAGS_NO_NORM)) {
for(j=0; j<k; j++)
for(l=0; l<d; l++) {
float nf = sqrt(n*g->w[j]/SIGMA(l,j));
if(nf > 0) DP_DMU(l,j) /= nf;
}
}
#undef DP_DMU
ii+=d*k;
}
if(flags & (GMM_FLAGS_SIGMA | GMM_FLAGS_1SIGMA)) {
if(flags & GMM_FLAGS_1SIGMA) { /* fast not implemented for 1 sigma */
for(j=0; j<k; j++) {
double accu2=0;
for(l=0; l<d; l++) {
double accu=0;
for(i=0; i<n; i++)
accu += P(j,i) * (sqr(V(l,i)-MU(l,j)) / SIGMA(l,j) - 1) / sqrt(SIGMA(l,j));
if(flags & GMM_FLAGS_SIGMA) {
double f=flags & GMM_FLAGS_NO_NORM ? 1.0 : 2*n*g->w[j]/SIGMA(l,j);
dp_dlambda[ii++]=accu/sqrt(f);
}
accu2+=accu;
}
if(flags & GMM_FLAGS_1SIGMA) {
double f=flags & GMM_FLAGS_NO_NORM ? 1.0 : 2*d*n*g->w[j]/SIGMA(0,j);
dp_dlambda[ii++]=accu2/sqrt(f);
}
}
} else { /* fast and complicated */
assert(flags & GMM_FLAGS_SIGMA);
float *dp_dsigma = dp_dlambda + ii;
if(!vp) {
vp = fvec_new(k * d);
fmat_mul_tr(v,p,d,k,n,vp);
}
if(!sum_pj) {
sum_pj = fvec_new(k);
for(j=0; j<k; j++) {
double sum=0;
for(i=0; i<n; i++) sum += P(j,i);
sum_pj[j] = sum;
}
}
float *v2 = fvec_new(n * d);
for(i = n*d-1 ; i >= 0; i--) v2[i] = v[i] * v[i];
float *v2p = fvec_new(k * d);
fmat_mul_tr(v2,p,d,k,n,v2p);
free(v2);
#define V2P(l,j) v2p[(j)*d+(l)]
#define DP_DSIGMA(i,j) dp_dsigma[(i)+(j)*d]
for(j=0; j<k; j++) {
for(l=0; l<d; l++) {
double accu;
accu = V2P(l, j);
accu += VP(l, j) * (- 2 * MU(l,j));
accu += sum_pj[j] * (sqr(MU(l,j)) - SIGMA(l,j));
/* normalization */
double f;
if(flags & GMM_FLAGS_NO_NORM) {
f = pow(SIGMA(l,j), -1.5);
} else {
f = 1 / (SIGMA(l,j) * sqrt(2*n*g->w[j]));
}
DP_DSIGMA(l,j) = accu * f;
}
}
free(v2p);
#undef DP_DSIGMA
#undef V2P
ii += d * k;
}
}
assert(ii==gmm_fisher_sizeof(g,flags));
#undef P
#undef V
#undef MU
#undef SIGMA
free(p);
free(sum_pj);
free(vp);
}
int S() { NP(); VP(); }
void selfie(libmaus2::util::ArgParser const & arg, std::string const & fn)
{
std::string const compactfn = fn + ".compact";
std::string const compactmetafn = compactfn + ".meta";
if (
! libmaus2::util::GetFileSize::fileExists(compactfn)
||
libmaus2::util::GetFileSize::isOlder(compactfn,fn)
)
{
libmaus2::fastx::FastAToCompact4BigBandBiDir::fastaToCompact4BigBandBiDir(
std::vector<std::string>(1,fn),
&(std::cerr),
false /* single strand */,
compactfn
);
}
uint64_t const numthreads =
arg.uniqueArgPresent("t") ? arg.getUnsignedNumericArg<uint64_t>("t") : libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions::getDefaultNumThreads();
std::string const bwtfn = fn + ".bwt";
std::string const bwtmetafn = bwtfn + ".meta";
libmaus2::suffixsort::bwtb3m::BwtMergeSortResult res;
if (
! libmaus2::util::GetFileSize::fileExists(bwtmetafn)
||
libmaus2::util::GetFileSize::isOlder(bwtmetafn,compactfn)
)
{
libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions options(
compactfn,
16*1024ull*1024ull*1024ull, // mem
// libmaus2::suffixsort::bwtb3m::BwtMergeSortOptions::getDefaultMem(),
numthreads,
"compactstream",
false /* bwtonly */,
std::string("mem:tmp_"),
std::string(), // sparse
bwtfn,
16 /* isa */,
16 /* sa */
);
res = libmaus2::suffixsort::bwtb3m::BwtMergeSort::computeBwt(options,&std::cerr);
res.serialise(bwtmetafn);
}
else
{
res.deserialise(bwtmetafn);
}
//libmaus2::fastx::FastAIndex::unique_ptr_type PFAI(libmaus2::fastx::FastAIndex::load(fn+".fai"));
libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::unique_ptr_type Pmeta(libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::load(compactmetafn));
libmaus2::rank::DNARank::unique_ptr_type Prank(res.loadDNARank(numthreads));
libmaus2::suffixsort::bwtb3m::BwtMergeSortResult::BareSimpleSampledSuffixArray BSSSA(res.loadBareSimpleSuffixArray());
uint64_t const n = Prank->size();
libmaus2::autoarray::AutoArray<char> A(n,false);
libmaus2::bitio::CompactDecoderWrapper CDW(compactfn);
CDW.read(A.begin(),n);
assert ( CDW.gcount() == static_cast<int64_t>(n) );
uint64_t const minfreq = 2;
uint64_t const minlen = 20;
uint64_t const limit = 32;
uint64_t const minsplitlength = 28;
uint64_t const minsplitsize = 10;
uint64_t const maxxdist = 1000;
uint64_t const activemax = 1;
uint64_t const fracmul = 95;
uint64_t const fracdiv = 100;
bool const selfcheck = true;
uint64_t const chainminscore = arg.uniqueArgPresent("chainminscore") ? arg.getUnsignedNumericArg<uint64_t>("chainminscore") : 20;
uint64_t const maxocc = 500;
uint64_t const minprintlength = 1024;
uint64_t const algndommul = 95;
uint64_t const algndomdiv = 100;
uint64_t const chaindommul = 95;
uint64_t const chaindomdiv = 100;
double const maxerr = arg.uniqueArgPresent("maxerr") ? arg.getParsedArg<double>("maxerr") : std::numeric_limits<double>::max();
uint64_t const cachek = arg.uniqueArgPresent("K") ? arg.getUnsignedNumericArg<uint64_t>("K") : 12;
uint64_t const maxpacksize = arg.uniqueArgPresent("P") ? arg.getUnsignedNumericArg<uint64_t>("P") : 128ull*1024ull*1024ull;
std::cerr << "[V] generating " << cachek << "-mer cache...";
libmaus2::rank::DNARankKmerCache::unique_ptr_type Pcache(new libmaus2::rank::DNARankKmerCache(*Prank,cachek,numthreads));
std::cerr << "done." << std::endl;
std::string const deftmp = libmaus2::util::ArgInfo::getDefaultTmpFileName(arg.progname);
libmaus2::util::TempFileNameGenerator tmpgen(deftmp,3);
std::string const sorttmp = tmpgen.getFileName();
libmaus2::util::TempFileRemovalContainer::addTempFile(sorttmp);
libmaus2::sorting::SortingBufferedOutputFile<CoordinatePair> CPS(sorttmp);
libmaus2::parallel::PosixSpinLock CPSlock;
uint64_t acc_s = 0;
for ( uint64_t zz = 0; zz < Pmeta->S.size(); )
{
uint64_t zze = zz;
uint64_t pack_s = Pmeta->S[zze++].l;
while ( zze < Pmeta->S.size() && pack_s + Pmeta->S[zze].l <= maxpacksize )
pack_s += Pmeta->S[zze++].l;
// std::cerr << "[V] " << zz << "-" << zze << " pack_s=" << pack_s << std::endl;
zz = zze;
uint64_t const low = acc_s;
uint64_t const high = acc_s + pack_s;
std::cerr << "[V] low=" << low << " high=" << high << " acc_s=" << acc_s << " pack_s=" << pack_s << std::endl;
std::string const activefn =
libmaus2::rank::DNARankSMEMComputation::activeParallel(tmpgen,*Pcache,A.begin(),low,high,minfreq,minlen,numthreads,maxxdist + 2*(minlen-1));
libmaus2::gamma::GammaIntervalDecoder::unique_ptr_type Pdec(new libmaus2::gamma::GammaIntervalDecoder(std::vector<std::string>(1,activefn),0/*offset */,1 /* numthreads */));
std::string const sortinfn = tmpgen.getFileName(true);
libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::unique_ptr_type sptr(
new libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>(sortinfn)
);
{
std::pair<uint64_t,uint64_t> P;
while ( Pdec->getNext(P) )
{
sptr->put(
GammaInterval(P.first,P.second)
);
}
}
libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type Pmerger(
sptr->getMerger()
);
struct LockedGet
{
libmaus2::parallel::PosixSpinLock lock;
// libmaus2::gamma::GammaIntervalDecoder& dec;
libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type & Pmerger;
LockedGet(libmaus2::sorting::SerialisingSortingBufferedOutputFile<GammaInterval>::merger_ptr_type & rPmerger) : Pmerger(rPmerger)
{
}
bool getNext(std::pair<uint64_t,uint64_t> & P)
{
bool ok = false;
{
libmaus2::parallel::ScopePosixSpinLock slock(lock);
GammaInterval Q;
ok = Pmerger->getNext(Q);
if ( ok )
{
P.first = Q.first;
P.second = Q.second;
}
}
return ok;
}
};
libmaus2::autoarray::AutoArray < std::pair<uint64_t,uint64_t> > VP(numthreads);
LockedGet LG(Pmerger);
libmaus2::fastx::CoordinateCacheBiDir cocache(*Prank,*Pmeta,16 /* blockshfit */);
typedef libmaus2::suffixsort::bwtb3m::BwtMergeSortResult::BareSimpleSampledSuffixArray sa_type;
typedef libmaus2::lcs::SMEMProcessor<sa_type> smem_proc_type;
libmaus2::autoarray::AutoArray < smem_proc_type::unique_ptr_type > Aproc(numthreads);
for ( uint64_t i = 0; i < numthreads; ++i )
{
smem_proc_type::unique_ptr_type proc(new smem_proc_type(
*Pmeta,cocache,*Prank,BSSSA,A.begin(),maxxdist,activemax,fracmul,fracdiv,selfcheck,chainminscore,maxocc,algndommul,algndomdiv,chaindommul,chaindomdiv,
libmaus2::lcs::NNP::getDefaultMaxWindowError(),libmaus2::lcs::NNP::getDefaultMaxBack(),false /* domsameref */
)
);
Aproc[i] = UNIQUE_PTR_MOVE(proc);
}
stateVec.resize(numthreads);
for ( uint64_t i = 0; i < numthreads; ++i )
setState(i,"idle");
#if defined(_OPENMP)
#pragma omp parallel num_threads(numthreads)
#endif
{
uint64_t const tid =
#if defined(_OPENMP)
omp_get_thread_num()
#else
0
#endif
;
std::pair<uint64_t,uint64_t> & P = VP[tid];
smem_proc_type & proc = *(Aproc[tid]);
struct SelfieVerbosity : public smem_proc_type::Verbosity
{
uint64_t tid;
std::string prefix;
SelfieVerbosity(uint64_t const rtid, std::string const & rprefix)
: tid(rtid), prefix(rprefix)
{
}
void operator()(libmaus2::rank::DNARankMEM const & smem, uint64_t const z) const
{
std::ostringstream ostr;
ostr << prefix << "\t" << z << "\t" << smem;
setState(tid,ostr.str());
printState();
}
};
while ( LG.getNext(P) )
{
uint64_t const smemleft = std::max(static_cast<int64_t>(0),static_cast<int64_t>(P.first)-static_cast<int64_t>(minlen-1));
uint64_t const smemright = std::min(P.second+minlen,n);
std::ostringstream msgstr;
msgstr << "[" << smemleft << "," << smemright << ")";
setState(tid,msgstr.str());
printState();
libmaus2::rank::DNARankSMEMComputation::SMEMEnumerator<char const *> senum(
*Prank,A.begin(),
smemleft,
smemright,
minfreq,
minlen,
limit,
minsplitlength,
minsplitsize);
SelfieVerbosity SV(tid,msgstr.str());
proc.process(senum,A.begin(),n,minprintlength,maxerr,SV);
// proc.printAlignments(minprintlength);
std::pair<libmaus2::lcs::ChainAlignment const *, libmaus2::lcs::ChainAlignment const *> const AP =
proc.getAlignments();
for ( libmaus2::lcs::ChainAlignment const * it = AP.first; it != AP.second; ++it )
{
libmaus2::lcs::ChainAlignment const & CA = *it;
libmaus2::lcs::NNPAlignResult const & res = CA.res;
std::vector<libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::Coordinates> const VA = Pmeta->mapCoordinatePairToList(res.abpos,res.aepos);
std::vector<libmaus2::fastx::DNAIndexMetaDataBigBandBiDir::Coordinates> const VB = Pmeta->mapCoordinatePairToList(res.bbpos,res.bepos);
if ( VA.size() == 1 && VB.size() == 1 )
{
CoordinatePair CP(VA[0],VB[0],res);
libmaus2::parallel::ScopePosixSpinLock slock(CPSlock);
CPS.put(CP);
}
}
setState(tid,"idle");
printState();
#if 0
std::cerr << "P=[" << P.first << "," << P.second << ")" << std::endl;
{
std::vector<libmaus2::rank::DNARankMEM> SMEM;
libmaus2::rank::DNARankSMEMComputation::smemLimitedParallel(
*Prank,
*Pcache,
A.begin(),
P.first,
P.second,
n,
minfreq,
minlen,
limit,
SMEM,
1 /* threads */);
std::cerr << "[V] number of SMEMs is " << SMEM.size() << std::endl;
// deallocate k-mer cache
// Pcache.reset();
std::vector<libmaus2::rank::DNARankMEM> SMEMsplit;
libmaus2::rank::DNARankSMEMComputation::smemLimitedParallelSplit(*Prank,A.begin(),P.first,P.second,minlen,limit,minsplitlength,minsplitsize,SMEM,SMEMsplit,1 /* threads */);
std::cerr << "[V] number of split SMEMs is " << SMEMsplit.size() << std::endl;
// insert split SMEMs into regular SMEMs
std::copy(SMEMsplit.begin(),SMEMsplit.end(),std::back_insert_iterator< std::vector<libmaus2::rank::DNARankMEM> >(SMEM));
//libmaus2::sorting::InPlaceParallelSort::inplacesort2(SMEM.begin(),SMEM.end(),numthreads,libmaus2::rank::DNARankMEMPosComparator());
std::sort(SMEM.begin(),SMEM.end(),libmaus2::rank::DNARankMEMPosComparator());
SMEM.resize(std::unique(SMEM.begin(),SMEM.end())-SMEM.begin());
libmaus2::rank::DNARankSMEMComputation::SMEMEnumerator<char const *> senum(
*Prank,A.begin(),
std::max(static_cast<int64_t>(0),static_cast<int64_t>(P.first)-static_cast<int64_t>(minlen-1)),
std::min(P.second+minlen,n),
minfreq,
minlen,
limit,
minsplitlength,
minsplitsize);
libmaus2::rank::DNARankMEM smem;
uint64_t c = 0;
while ( senum.getNext(smem) )
{
// std::cerr << "ccc=" << smem << std::endl;
if ( c >= SMEM.size() || smem != SMEM[c] )
{
std::cerr << "mismatch " << c << " " << smem;
if ( c < SMEM.size() )
std::cerr << " != " << SMEM[c];
else
std::cerr << " ???";
std::cerr << std::endl;
}
else
{
std::cerr << "match " << c << " " << smem << " " << SMEM[c] << std::endl;
}
++c;
}
std::cerr << "c=" << c << " V=" << SMEM.size() << std::endl;
}
#endif
}
}
acc_s += pack_s;
}
libmaus2::sorting::SortingBufferedOutputFile<CoordinatePair>::merger_ptr_type Pmerger(CPS.getMerger());
CoordinatePair CP;
while ( Pmerger->getNext(CP) )
{
std::ostringstream ostr;
CP.A.print(ostr);
ostr << " ";
CP.B.print(ostr);
ostr << " ";
ostr << CP.res.getErrorRate();
std::cout << ostr.str() << std::endl;
}
}
int S() { printf("<S>"); NP(); VP(); printf("</S>"); }
void VLCHolderWnd::LibVlcAttach()
{
if( VP() )
libvlc_media_player_set_hwnd( VP()->get_mp(), hWnd() );
}
void
handle_events(int fd)
{
node_contract_t *cp;
const nc_descr_t *dp;
ct_evthdl_t eh;
ctid_t ctid;
uint_t evtype;
ctevid_t evid;
ctevid_t nevid;
ctid_t newct;
uint_t flags;
nvlist_t *ap, *sap, *rp;
const char *evtypename;
int err;
while ((err = ct_event_read(fd, &eh)) == 0) {
ctid = ct_event_get_ctid(eh);
cp = nc_lookup(ctid);
/*
* This contract has gone away. This should be possible only
* if we've already abandoned it, but it may be possible to
* receive events for it after that. We can't even ack here,
* because we don't have the ctl fd for the contract any more.
* Just keep going; there's nothing we can do.
*/
if (cp == NULL) {
ct_event_free(eh);
++ev_failures;
continue;
}
dp = cp->nc_type->nct_events;
evtype = ct_event_get_type(eh);
evtypename = nc_descr_strlookup(dp, evtype);
evid = ct_event_get_evid(eh);
flags = ct_event_get_flags(eh);
sap = v8plus_obj(
VP(ctid, NUMBER, (double)ctid),
VP(evid, STRNUMBER64, (uint64_t)evid),
VP(type, STRING, evtypename),
VP_V(flags, INL_OBJECT),
VP(info, BOOLEAN, (flags & CTE_INFO) != 0),
VP(ack, BOOLEAN, (flags & CTE_ACK) != 0),
VP(neg, BOOLEAN, (flags & CTE_NEG) != 0),
V8PLUS_TYPE_NONE,
V8PLUS_TYPE_NONE);
if (sap == NULL) {
ct_event_free(eh);
++ev_failures;
continue;
}
if (evtype == CT_EV_NEGEND) {
(void) ct_event_get_nevid(eh, &nevid);
(void) ct_event_get_newct(eh, &newct);
err = v8plus_obj_setprops(sap,
VP(nevid, STRNUMBER64, (uint64_t)nevid),
VP(newct, NUMBER, (double)newct),
V8PLUS_TYPE_NONE);
if (err != 0) {
nvlist_free(sap);
ct_event_free(eh);
++ev_failures;
continue;
}
}
ap = v8plus_obj(
VP(0, STRING, evtypename),
VP(1, OBJECT, sap),
V8PLUS_TYPE_NONE);
nvlist_free(sap);
ct_event_free(eh);
if (ap == NULL) {
++ev_failures;
continue;
}
rp = v8plus_method_call(cp, "_emit", ap);
nvlist_free(ap);
nvlist_free(rp);
}
if (err != EAGAIN) {
v8plus_panic("unexpected error from ct_event_read: %s",
strerror(err));
}
}
