MySQL Join

Cross Join
Genelde aynı tabloyu kartezyen çarpıma tabi tutmak için kullanılır. A tablosunda şu satırlar olsun.

'ta1'
'ta2'
'ta3'
'ta4'

Şöyle yaparız.

SELECT 
 A.name,
 B.name FROM ta A CROSS JOIN ta B 
WHERE A.id <> B.id

Şu çıktıyı elde ederiz.

|    ta1 |    ta2 |
|    ta1 |    ta3 |
|    ta1 |    ta4 |
|    ta2 |    ta1 |
|    ta2 |    ta3 |
|    ta2 |    ta4 |
|    ta3 |    ta1 |
|    ta3 |    ta2 |
|    ta3 |    ta4 |
|    ta4 |    ta1 |
|    ta4 |    ta2 |
|    ta4 |    ta3 |

Farklı iki tabloyu kartezyen çarpıma tabi tutmak için şöyle yaparız.

insert into C(myString_A, myString_B)
    select a.myString_A, b.myString_B
    from Table_A a cross join
         Table_B b;

Inner Join
Tablodaki en büyük x değerine sahip satırı buluruz. Bu cümleden id ve revision değerleri gelir. Ancak geri kalan sütunları teker teker yazmak istemeyiz. Tabloyu kendi içinde birleştirerek geriye kalan sütunları da almak için şöyle yaparız.

SELECT t.*
FROM your_table t
INNER JOIN
  (SELECT id, MAX(revision) revision FROM your_table GROUP BY id
  ) t1
ON t.id        = t1.id
AND t.revision = t1.revision;

Left Join
On kelimesinden sonra gelen = kontrolü istenilen sırada yazılabilir. Şöyle yaparız

select fields 
from tableA 
LEFT JOIN tableB 
ON tableA.key = tableB.key

veya şöyle yaparız.

select fields 
from tableA 
LEFT JOIN tableB 
ON tableA.key = tableB.key

QueryPerformanceCounter

Giriş 
Şu satırı dahil ederiz.

#include <windows.h>

Hassasiyeti (precision) nanosaniye cinsinden . Windows'un doğruluğu (accuracy) 200-300 mikrosaniye civarında.

Örnek 1
Şöyle yaparız. Frequency 1 saniyedeki tick sayısıdır. (Tick sayısı / Frequency) bölümü bize saniye verir. Saniyeyi milisaniyeye çevirmek için 1000 ile çarparız.

long long milliseconds_now() {
  static LARGE_INTEGER s_frequency;
  static BOOL s_use_qpc = QueryPerformanceFrequency(&s_frequency);
  
  LARGE_INTEGER now;
  QueryPerformanceCounter(&now);
  return (1000LL * now.QuadPart) / s_frequency.QuadPart;
  
}

Daha sonra şöyle yaparız.

// Somewhere else...
// ...
long long start = milliseconds_now();
// ....
long long elapsed = milliseconds_now() - start;

Örnek 2
Milisaniyeye çevirmek için 1000 ile çarpma yerine frekansın birimini en baştan değiştirebiliriz. Şöyle yaparız.

#include <windows.h>

double PCFreq = 0.0;
__int64 CounterStart = 0;

void StartCounter()
{
  LARGE_INTEGER li;
  if(!QueryPerformanceFrequency(&li))
  cout << "QueryPerformanceFrequency failed!\n";

  PCFreq = double(li.QuadPart)/1000.0;

  QueryPerformanceCounter(&li);
  CounterStart = li.QuadPart;
}
double GetCounter()
{
  LARGE_INTEGER li;
  QueryPerformanceCounter(&li);
  return double(li.QuadPart-CounterStart)/PCFreq;
}

int main()
{
  StartCounter();
  Sleep(1000);
  cout << GetCounter() <<"\n";
  return 0;
}

Posix Eşzamanlılık Yapıları - Read Write Lock

Giriş
Şu satırı dahil ederiz.

#include <pthread.h>

Read Write kilitleri için iki tane farklı çözüm var. İlk çözümde Reader'lar  en az bekleyeme uğrarken, ikinci çözümde Writer'lar en az beklemeye uğruyor. Yani hangisinin öncelikli olduğu çözüme göre değişebiliyor.

Bir Read Write kilidi için 2 semaphore, 3 mutex ve iki integer değişken lazımmış.

PTHREAD_RWLOCK_INITIALIZER Macrosu
Şöyle yaparız.

pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;

pthread_rwlock_init metodu
Şöyle yaparız.

pthread_rwlockattr_t attr;
pthread_rwlockattr_init(&attr);
pthread_rwlockattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);

pthread_rwlock_init(&rwlock, &attr);

pthread_rwlock_rdlock metodu
Okuma kilidi alır. Şöyle yaparız.

pthread_rwlock_rdlock(&rw_lock);

Hata kontrolü yapmak istersek şöyle yaparız.

if (pthread_rwlock_rdlock(&rw_lock) != 0) {
  perror("reader_thread: pthread_rwlock_rdlock error");
  exit(__LINE__);
}

pthread_rwlock_tryrdlock metodu
Örnek ver

pthread_rwlock_wrlock metodu
Write lock alır. Şöyle yaparız.

pthread_rwlock_wrlock(&rw_lock); 

Hata kontrolü yapmak istersek şöyle yaparız.

if (pthread_rwlock_wrlock(&rw_lock) != 0) {
  perror("writer thread: pthread_rwlock_wrlock error");
  exit(__LINE__);
}

pthread_rwlock_trywrlock metodu
Örnek ver

pthread_rwlock_unlock metodu

Read veya Write lock'i bırakır. Şöyle yaparız.

pthread_rwlock_unlock(&rw_lock);

Hata kontrolü yapmak istersek şöyle yaparız.

if (pthread_rwlock_unlock(&rw_lock) != 0) {
  perror("reader thread: pthred_rwlock_unlock error");
  exit(__LINE__);
}

OpenCv connectedComponents

Giriş
Açıklaması şöyle

Connected component labeling is a procedure for assigning a unique label to each object (a group of
connected components) in an image. These labels are the keys for any subsequent analysis procedure and are used for distinguishing and referencing the objects. This makes connected component labeling an indispensable part of nearly all applications in pattern recognition and computer
vision. For example, before a computer can detect or classify any object in an image, be it a car,
a person, or a lesion, groups of similar pixels are identified and labeled. Each group is generally
referred to as an object.

Identifying all pixels in a group enables one to compute the information required for subsequent processing, such as area size, height, width, and perimeter. Clearly, connected component labeling is one of the most fundamental algorithms of image analysis. In many cases, it is also one of the most time-consuming tasks among other pattern-recognition algorithms. For these reasons, connected component labeling continues to remain an active area of research.

API'nin açıklaması şöyle. İki tane algoritma sunuyor. CCL_WU 4 bağlantı varsa kullanılır. CCL_GRANA sadece 8 tane bağlantı varsa kullanılır.

       \  connectivity   4    |   8
        \                     |
type     \                    |
                              |
CCL_DEFAULT              Wu   |  Grana
CCL_WU                   Wu   |  Wu
CCL_GRANA                Wu   |  Grana

argp

Giriş
Şu satırları dahil ederiz.

#include <stdio.h>
#include <argp.h>
#include <string.h>

argp yöntemi, getop yöntemine göre biraz daha gelişmiş özellikler sunar.

argp_parse metodu
Şöyle yaparız.

int main(int argc, char **argv) {
  struct argp_option const options[] = {
      {"char", 'c', "c", 0, "a super char", 0}, {0}};
  struct argp const argp = {options, &parse_opt, NULL, NULL, NULL, NULL, NULL};
  argp_parse(&argp, argc, argv, 0, NULL, NULL);
}

parser
Şöyle yaparız.

static int parse_opt(int key, char *arg, struct argp_state *state) {
  (void)state; // We don't use state
  switch (key) {
    case 'c': {
      if (strlen(arg) == 1) { // we only want one char
        char c = *arg;        // or arg[0]
        printf("my super char %c !!!\n", c);
      } else {
        return 1;
      }
    }
  }
  return 0;
}

CreateThread

Giriş
Şu satırı dahil ederiz.

#include <Windows.h>

CreateThread metodu
Şöyle yaparız.

DWORD threadID;
HANDLE hThread = CreateThread (NULL, 0, ThreadFunction, NULL, 0, &threadID1);

Thread metodunun imzası şöyle

DWORD WINAPI ThreadFunction(_In_ LPVOID lpParameter);

Metodun içi şöyle

DWORD WINAPI ThreadFunction()
{
  ...
  return 0;
}

Thread'in bitmesini beklemek için threadID üzerinde WaitForSingleObject yapılır.
Daha sonra thread'in handle'ını kapatmak için şöyle yaparız.

CloseHandle (hThread1);