main()
{
char s[]="ramya";
char t[]="sruthi";
remove_dups(s);
remove_dups(t);
printf("s=%s\nt=%s\n",s,t);
}
int main() {
Node* n = new Node(0);
n->push_back(0);
n->push_back(1);
n->push_back(2);
n->push_back(2);
n->push_back(3);
n->push_back(4);
n->push_back(1);
remove_dups(n);
return 1;
}
int foreach_wif(int include_vifs, void *param,
int (*func)(int idx, int unit, int subunit, void *param))
{
char ifnames[256];
char name[64], ifname[64], *next = NULL;
int unit = -1, subunit = -1;
int i;
int ret = 0;
snprintf(ifnames, sizeof(ifnames), "%s %s %s %s %s %s %s %s %s %s",
nvram_safe_get("lan_ifnames"),
nvram_safe_get("lan1_ifnames"),
nvram_safe_get("lan2_ifnames"),
nvram_safe_get("lan3_ifnames"),
nvram_safe_get("wan_ifnames"),
nvram_safe_get("wl_ifname"),
nvram_safe_get("wl0_ifname"),
nvram_safe_get("wl0_vifs"),
nvram_safe_get("wl1_ifname"),
nvram_safe_get("wl1_vifs"));
remove_dups(ifnames, sizeof(ifnames));
sort_list(ifnames, sizeof(ifnames));
i = 0;
foreach(name, ifnames, next) {
if (nvifname_to_osifname(name, ifname, sizeof(ifname)) != 0)
continue;
if (wl_probe(ifname) || wl_ioctl(ifname, WLC_GET_INSTANCE, &unit, sizeof(unit)))
continue;
// Convert eth name to wl name
if (osifname_to_nvifname(name, ifname, sizeof(ifname)) != 0)
continue;
// Slave intefaces have a '.' in the name
if (strchr(ifname, '.') && !include_vifs)
continue;
if (get_ifname_unit(ifname, &unit, &subunit) < 0)
continue;
ret |= func(i++, unit, subunit, param);
}
return ret;
}
int32_t db_query (struct db *d, uint32_t key, uint32_t **values)
{
int j;
uint32_t* list = NULL;
list = (uint32_t*) malloc(sizeof(uint32_t)*listSize);
if(list == NULL){
printf("Error allocating memory\n");
exit(-1);
}
for(j = 0; j < listSize; j++)
list[j] = rand() % maxValue;
qsort(list, listSize, sizeof(uint32_t), uint32_t_cmp);
*values = list;
// printf("Returning created list...\n");
return remove_dups(list, listSize);
}
//------------------------------------------------------------------------------
// Fisherfaces
//------------------------------------------------------------------------------
void Fisherfaces::train(InputArrayOfArrays src, InputArray _lbls) {
if(src.total() == 0) {
String error_message = format("Empty training data was given. You'll need more than one sample to learn a model.");
CV_Error(Error::StsBadArg, error_message);
} else if(_lbls.getMat().type() != CV_32SC1) {
String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _lbls.type());
CV_Error(Error::StsBadArg, error_message);
}
// make sure data has correct size
if(src.total() > 1) {
for(int i = 1; i < static_cast<int>(src.total()); i++) {
if(src.getMat(i-1).total() != src.getMat(i).total()) {
String error_message = format("In the Fisherfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", src.getMat(i-1).total(), src.getMat(i).total());
CV_Error(Error::StsUnsupportedFormat, error_message);
}
}
}
// get data
Mat labels = _lbls.getMat();
Mat data = asRowMatrix(src, CV_64FC1);
// number of samples
int N = data.rows;
// make sure labels are passed in correct shape
if(labels.total() != (size_t) N) {
String error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", N, labels.total());
CV_Error(Error::StsBadArg, error_message);
} else if(labels.rows != 1 && labels.cols != 1) {
String error_message = format("Expected the labels in a matrix with one row or column! Given dimensions are rows=%s, cols=%d.", labels.rows, labels.cols);
CV_Error(Error::StsBadArg, error_message);
}
// clear existing model data
_labels.release();
_projections.clear();
// safely copy from cv::Mat to std::vector
std::vector<int> ll;
for(unsigned int i = 0; i < labels.total(); i++) {
ll.push_back(labels.at<int>(i));
}
// get the number of unique classes
int C = (int) remove_dups(ll).size();
// clip number of components to be a valid number
if((_num_components <= 0) || (_num_components > (C-1)))
_num_components = (C-1);
// perform a PCA and keep (N-C) components
PCA pca(data, Mat(), PCA::DATA_AS_ROW, (N-C));
// project the data and perform a LDA on it
LDA lda(pca.project(data),labels, _num_components);
// store the total mean vector
_mean = pca.mean.reshape(1,1);
// store labels
_labels = labels.clone();
// store the eigenvalues of the discriminants
lda.eigenvalues().convertTo(_eigenvalues, CV_64FC1);
// Now calculate the projection matrix as pca.eigenvectors * lda.eigenvectors.
// Note: OpenCV stores the eigenvectors by row, so we need to transpose it!
gemm(pca.eigenvectors, lda.eigenvectors(), 1.0, Mat(), 0.0, _eigenvectors, GEMM_1_T);
// store the projections of the original data
for(int sampleIdx = 0; sampleIdx < data.rows; sampleIdx++) {
Mat p = LDA::subspaceProject(_eigenvectors, _mean, data.row(sampleIdx));
_projections.push_back(p);
}
}
void iptraffic_conntrack_init() {
unsigned int a_time, a_proto;
char a_src[INET_ADDRSTRLEN];
char a_dst[INET_ADDRSTRLEN];
char b_src[INET_ADDRSTRLEN];
char b_dst[INET_ADDRSTRLEN];
char sa[256];
char sb[256];
FILE *a;
char *p;
int x;
Node tmp;
Node *ptr;
unsigned long rip[4];
unsigned long lan[4];
unsigned long mask[4];
unsigned short int br;
for(br=0 ; br<=3 ; br++) {
char bridge[2] = "0";
if (br!=0)
bridge[0]+=br;
else
strcpy(bridge, "");
sprintf(sa, "lan%s_ifname", bridge);
if (strcmp(nvram_safe_get(sa), "") != 0) {
sprintf(sa, "lan%s_ipaddr", bridge);
rip[br] = inet_addr(nvram_safe_get(sa));
sprintf(sa, "lan%s_netmask", bridge);
mask[br] = inet_addr(nvram_safe_get(sa));
lan[br] = rip[br] & mask[br];
// _dprintf("rip[%d]=%lu\n", br, rip[br]);
// _dprintf("mask[%d]=%lu\n", br, mask[br]);
// _dprintf("lan[%d]=%lu\n", br, lan[br]);
} else {
mask[br] = 0;
rip[br] = 0;
lan[br] = 0;
}
}
const char conntrack[] = "/proc/net/ip_conntrack";
if ((a = fopen(conntrack, "r")) == NULL) return;
ctvbuf(a); // if possible, read in one go
while (fgets(sa, sizeof(sa), a)) {
if (sscanf(sa, "%*s %u %u", &a_proto, &a_time) != 2) continue;
if ((a_proto != 6) && (a_proto != 17)) continue;
if ((p = strstr(sa, "src=")) == NULL) continue;
if (sscanf(p, "src=%s dst=%s %n", a_src, a_dst, &x) != 2) continue;
p += x;
if ((p = strstr(p, "src=")) == NULL) continue;
if (sscanf(p, "src=%s dst=%s", b_src, b_dst) != 2) continue;
snprintf(sb, sizeof(sb), "%s %s %s %s", a_src, a_dst, b_src, b_dst);
remove_dups(sb, sizeof(sb));
char ipaddr[INET_ADDRSTRLEN], *next = NULL;
char skip;
foreach(ipaddr, sb, next) {
skip = 1;
for(br=0 ; br<=3 ; br++) {
if ((mask[br] != 0) && ((inet_addr(ipaddr) & mask[br]) == lan[br])) {
skip = 0;
break;
}
}
if (skip == 1) continue;
strncpy(tmp.ipaddr, ipaddr, INET_ADDRSTRLEN);
ptr = TREE_FIND(&tree, _Node, linkage, &tmp);
if (!ptr) {
_dprintf("%s: new ip: %s\n", __FUNCTION__, ipaddr);
TREE_INSERT(&tree, _Node, linkage, Node_new(ipaddr));
ptr = TREE_FIND(&tree, _Node, linkage, &tmp);
}
if (a_proto == 6) ++ptr->tcp_conn;
if (a_proto == 17) ++ptr->udp_conn;
}
}
void FisherFaceRecognizer::train(InputArrayOfArrays _in_src, InputArray _inm_labels, bool preserveData)
{
if (_in_src.kind() != _InputArray::STD_VECTOR_MAT && _in_src.kind() != _InputArray::STD_VECTOR_VECTOR)
{
String error_message = "The images are expected as InputArray::STD_VECTOR_MAT (a std::vector<Mat>) or _InputArray::STD_VECTOR_VECTOR (a std::vector< std::vector<...> >).";
CV_Error(CV_StsBadArg, error_message);
}
if (_in_src.total() == 0)
{
String error_message = format("Empty training data was given. You'll need more than one sample to learn a model.");
CV_Error(CV_StsUnsupportedFormat, error_message);
}
else if (_inm_labels.getMat().type() != CV_32SC1)
{
String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _inm_labels.type());
CV_Error(CV_StsUnsupportedFormat, error_message);
}
// get the vector of matrices
std::vector<Mat> src;
_in_src.getMatVector(src);
// get the label matrix
Mat labels = _inm_labels.getMat();
// check if data is well- aligned
if (labels.total() != src.size())
{
String error_message = format("The number of samples (src) must equal the number of labels (labels). Was len(samples)=%d, len(labels)=%d.", src.size(), m_labels.total());
CV_Error(CV_StsBadArg, error_message);
}
// if this model should be trained without preserving old data, delete old model data
if (!preserveData)
{
m_labels.release();
m_src.clear();
}
// append labels to m_labels matrix
for (size_t labelIdx = 0; labelIdx < labels.total(); labelIdx++)
{
m_labels.push_back(labels.at<int>((int)labelIdx));
m_src.push_back(src[(int)labelIdx]);
}
// observations in row
Mat data = asRowMatrix(m_src, CV_64FC1);
// number of samples
int n = data.rows;
/*
LDA needs more than one class
We have to check the labels first
*/
bool label_flag = false;
for (int i = 1 ; i < m_labels.rows ; i++)
{
if (m_labels.at<int>(i, 0)!=m_labels.at<int>(i-1, 0))
{
label_flag = true;
break;
}
}
if (!label_flag)
{
String error_message = format("The labels should contain more than one types.");
CV_Error(CV_StsBadArg, error_message);
}
// clear existing model data
m_projections.clear();
std::vector<int> ll;
for (unsigned int i = 0 ; i < m_labels.total() ; i++)
{
ll.push_back(m_labels.at<int>(i));
}
// get the number of unique classes
int C = (int) remove_dups(ll).size();
// clip number of components to be valid
m_num_components = (C-1);
// perform the PCA
PCA pca(data, Mat(), PCA::DATA_AS_ROW, (n-C));
LDA lda(pca.project(data),m_labels, m_num_components);
// Now calculate the projection matrix as pca.eigenvectors * lda.eigenvectors.
// Note: OpenCV stores the eigenvectors by row, so we need to transpose it!
gemm(pca.eigenvectors, lda.eigenvectors(), 1.0, Mat(), 0.0, m_eigenvectors, GEMM_1_T);
// store the projections of the original data
for (int sampleIdx = 0 ; sampleIdx < data.rows ; sampleIdx++)
{
Mat p = LDA::subspaceProject(m_eigenvectors, m_mean, data.row(sampleIdx));
m_projections.push_back(p);
}
}
