Search is not available for this dataset
text
stringlengths 0
3.2M
| lang
stringclasses 14
values |
|---|---|
सूजी के हलवे से घुलती है मिठास हर त्यौहार कि कोई न कोई स्पेशल डिश होती है. हालांकि कुछ ऐसी डिशेज भी हैं जो कि पूरी तरह से पारंपरिक है और कभी भी आसानी से बनाई जा सकती हैं. ऐसी ही एक डिश है सूजी का हलवा. यह आसानी से बनने वाली और टेस्टी पारंपरिक मिठाई है. घर में अचानक कोई मेहमान आ जाए तो उसके लिए भी झटपट सूजी का हलवा तैयार किया जा सकता है. हम आपको इसे बनाने के लिए स्टेप बाय स्टेप रेसिपी बनाने की विधि सिखाते हैं. सामग्री: सूजी रवा 12 कप घी 13 कप पानी सवा कप चीनी 12 कप काजू कटे 5 बादाम कटे 5 इलायची पाउडर 14 टी स्पून विधि:एक बर्तन में सवा कप पानी लें और उसे मध्यम आंच पर उबालें. इसमें लगभग तीन से चार मिनट का वक्त लग जाएगा. अब गैस बंद कर पानी अलग रख दें. अब एक कढ़ाही लें और उसमें घी डालकर गर्म करें. घी पिघलने के बाद उसमें सूजी डाल दें. अब दोनों को अच्छी तरह से मिलाएं. अब इस मिश्रण को मीडियम आंच पर तब तक भूनें जब तक इसका रंग सुनहरा न हो जाए. ऐसा होने में लगभग 10 मिनट का वक्त लगेगा.अब आंच को धीमा कर दें और इसमें धीरेधीरे उबला हुआ पानी डालें. इस दौरान इसे लगातार चम्मच से हिलाते रहें. मिश्रण को चम्मच से अच्छी तरह से चलाएं जिससे हलवे में गांठ न बने. अब आंच को मीडियम करें और पानी सुखाएं. अब इसमें इलायची पाउडर और चीनी डालें. जब तक चीनी न पिघल जाए और मिश्रण और भी गाढ़ा न हो जाए तब तक इसे पकाएं. इसके बाद इसमें काजू और बादाम के टुकड़े डालकर अच्छे से हलवे के साथ मिलाएं. हलवा बनने के बाद इसमें ऊपर से भी काजू और बादाम के टुकड़े डाल दें. अब सूजी का हलवा सर्व करने के लिए पूरी तरह से तैयार हो गया है. | hindi |
અતિ મહત્વનું! યાત્રાધામ શક્તિપીઠ અંબાજી મંદિરનો મહત્વનો નિર્ણય, મંદિરના દર્શન અને આરતીના સમયમાં ફેરફાર કરવામાં આવ્યો, ગુજરાત રાજ્યના પ્રસિદ્ધ યાત્રાધામ શક્તિપીઠ અંબાજી મંદિરના શ્રદ્ધાળુઓ માટે મહત્વના અહેવાલ સામે આવ્યા છે. જેમાં યાત્રાધામ શક્તિપીઠ અંબાજી મંદિરમાં દર્શન અને આરતીના સમયમાં ફેરફાર કરવામાં આવ્યો છે. સૂર્યોદય અને સૂર્યાસ્તના સમય પ્રમાણે દર્શન અને આરતીના સમયમાં ફેરફાર કરાયો છે. સવારે 7થી 730 વાગ્યે આરતી થશે. ૩૦ જૂન સુધી આરતીના સમયમાં કરાયો ફેરફાર સવારે ૭.૦૦ થી ૭.૩૦ વાગ્યે સવારે દર્શન ૭.૩૦ થી ૧૦.૪૫ વાગ્યે રાજભોગ આરતી બપોરે ૧૨.૩૦ થી ૧.૦૦ વાગ્યે બપોરે દર્શન ૧.૦૦ થી ૪.૩૦ વાગ્યે સાંજે આરતી ૭.૦૦ થી ૭૩૦ સવારના દર્શન 730થી 1045 સુધી થઈ શકશે. રાજભોગ આરતી 1230 થી 1 વાગ્યે થશે. બપોરે 100થી 430 વાગ્યા સુધી દર્શન થઈ શકશે. સાંજે 7થી 730 વાગ્યે આરતી થશે. અને સાંજના દર્શન 730 થી 9 વાગ્યા સુધી થઈ શકશે. | gujurati |
आज शुरू होगा श्रीमद्भागवत महापुराण ज्ञान यज्ञ Shrimad Bhagwat Mahapuran Gyan Yagya Will Start Today Shrimad Bhagwat Mahapuran Gyan Yagya Will Start Today नीरज कौशिक, महेंद्रगढ़: Shrimad Bhagwat Mahapuran Gyan Yagya Will Start Today : महेंद्रगढ़ के गांव मालड़ा में समस्त ग्रामवासियों के सहयोग से बाबा सदाराम मंदिर प्रांगण में सात दिवसीय संगीतमय श्रीमद्भागवत महापुराण ज्ञान यज्ञ एक फरवरी से शुरू होगा। Shrimad Bhagwat Mahapuran Gyan Yagya Will Start Today इससे पूर्व सोमवार को पूरे गांव में हर्षोल्लास से कलश यात्रा निकाली गई। कथा से पहले निकाली कलश यात्रा सामाजिक कार्यकर्ता सुजान मालड़ा ने बताया कि कथा शुरू होने से पूर्व कलश यात्रा निकाली गई। कलश यात्रा बाबा सदाराम मंदिर से शुरू होकर पूरे गांव में परिक्रमा के बाद वापस मंदिर परिसर में पहुंचकर संपन्न हुई। इसमें सैकड़ों महिला, पुरूष एवं बच्चे शामिल हुए। Shrimad Bhagwat Mahapuran Gyan Yagya Will Start Today कथा का संचालन बालयोगी प्रदीप कृष्ण महाराज और उनके सहयोगियों की ओर से प्रात: 11 बजे से दोपहर 2 बजे तक किया जाएगा। गीता से विचारों में आता बदलाव बालयोगी प्रदीप कृष्ण महाराज ने कहा कि संगीतमय Shrimad Bhagwat Mahapuran Gyan Yagya Will Start Today श्रीमद्भागवत महापुराण ज्ञान यज्ञ समयसमय पर होते रहने चाहिए। जिसके सुनने मात्र से हमारे विचारों में बेहद बदलाव आता है। इसके थोड़े से ज्ञान ग्रहण करने से हमारा जीवन सुखमय हो जाता है। हमें इस भागदौड़ भरी जिंदगी से कुछ समय निकल कर गीता के उपदेश व महापुराण को भी पढ़ना चाहिए। Also Read : RSMSSB APRO Recruitment 2022 एपीआरओ पदों पर भर्ती, 14 फरवरी तक आवेदन Connect With Us : Twitter Facebook | hindi |
ఆక్సిజన్ కొరతతో ఎవరూ చనిపోలేదన్న కేంద్రం, మరి రుయా ఆస్పత్రిలో మరణాలెలా సంభవించాయి? దేశంలో ఆక్సిజన్ కొరత కారణంగా ప్రాణాలు కోల్పోయిన ఘటనలు లేవు. ఏ ఒక్క రాష్ట్ర ప్రభుత్వం గానీ, కేంద్ర పాలిత ప్రాంతంగానీ ఆక్సిజన్ కొరతతో రోగులు చనిపోయినట్లు నివేదించలేదు. కోవిడ్ మృతుల వివరాలు దాచిపెట్టాల్సిన అవసరం మాకు లేదు. కేవలం ప్రోటోకాల్ని అనుసరించి వివిధ రాష్ట్రాలు ఇచ్చిన గణాంకాలను మాత్రమే మేము వెల్లడించాం. ఇది కేంద్ర ప్రభుత్వ వివరణకోవిడ్ సెకండ్ వేవ్ సందర్భంగా దేశవ్యాప్తంగా ఆక్సిజన్ కొరతతో రోడ్లపైన, ఆస్పత్రి మెట్ల మీద రోగులు మరణించారా లేదా అనే ప్రశ్నకు సమాధానంగా కేంద్ర ప్రభుత్వం తరుపున రాజ్యసభలో సమాధానం ఇచ్చిన సందర్భంలో ఈ వివరణ ఇచ్చారు. ఈ అంశంపై కేంద్ర ఆరోగ్య శాఖ మంత్రి మన్సుఖ్ మాండవీయ, సహాయ మంత్రి భారతీ ప్రవీణ్ పవార్ కూడా స్పందించారు.అన్ని కోవిడ్ అప్డేట్స్ గురించి తెలుసుకునేందుకు ఇక్కడ చదవండిదేశవ్యాప్తంగా ఆక్సిజన్ కొరతతో ప్రాణాలు కోల్పోయిన కరోనా రోగులు ఎవరూ లేరని స్పష్టం చేశారు. ఆక్సిజన్ సమస్యతోనే రుయా ఆస్పత్రిలో కోవిడ్ రోగుల మరణాలుజూలై 20న కేంద్రం ఈ సమాధానం చెబితే సరిగ్గా 2 నెలల 10 రోజుల ముందు అంటే మే 10న తిరుపతి రుయా ఆస్పత్రిలో ఒకేసారి పెద్ద సంఖ్యలో కరోనా రోగులు చనిపోయారు. ఈ ఘటనలో 11 మంది మరణించారని ఆనాడు ప్రభుత్వం మొదట ప్రకటించింది. దానికి ప్రధాన కారణం ఆక్సిజన్ కొరత అని ముఖ్యమంత్రి వైఎస్ జగన్ ప్రకటించారు. ఘటనాస్థలంలో నాటి చిత్తూరు జిల్లా కలెక్టర్ అదే విషయం నిర్ధారణ చేశారు. ఆస్పత్రి వైద్యుల నివేదికలోనూ ధృవీకరించారు. ఇటీవల ఏపీ హైకోర్టులో ప్రభుత్వం దాఖలు చేసిన అఫిడవిట్లో కూడా పేర్కొన్నారు. అంతేకాకుండా మే 11న ప్రధాని నరేంద్ర మోడీకి సీఎం జగన్ రాసిన లేఖలో కూడా ఈ అంశం ప్రస్తావించారు. ఏపీలో ఆక్సిజన్ కొరత తీర్చేందుకు కేంద్రం సహాయాన్ని ఆయన అభ్యర్థించారు. తిరుపతి రుయా ఆస్పత్రిలో ఆక్సిజన్ సరిపడా లేక రోగులు ప్రాణాలు కోల్పోయిన విషయాన్ని ప్రధాని దృష్టికి తీసుకొచ్చారు. ఆక్సిజన్ సరఫరా విషయంలో తక్షణమే స్పందించాలని కోరుతూ, జాప్యం జరిగితే అలాంటి ఘటనలు పునరావృతమయ్యే ప్రమాదం ఉందని ఆందోళన వ్యక్తం చేశారు. కేంద్రం మాత్రం ఏమీ లేవంటోందిఆక్సిజన్ కొరతతో తిరుపతి రుయా ఆస్పత్రిలో మరణించిన వారి సంఖ్య తొలుత 11గా చెప్పిన ప్రభుత్వం ఆ తర్వాత దానిని 23గా ప్రకటించింది. బాధితులకు పరిహారం కూడా చెల్లించింది. ఏపీ ముఖ్యమంత్రి నేరుగా ప్రధానికి లేఖ రాశారు. బాధితులకు పరిహారం చెల్లిస్తూ నివేదికలో ప్రస్తావించారు. ఏపీ హైకోర్టు అఫిడవిట్లో కూడా కాంట్రాక్టర్ తప్పిదం వల్ల సకాలంలో ఆక్సిజన్ ట్యాంకులు ఆస్పత్రికి చేరలేదని తెలిపారు. అయినప్పటికీ కేంద్ర ప్రభుత్వం మాత్రం ఏ ఒక్క రాష్ట్రం నుంచి ఆక్సిజన్ కారణంగా సంభవించిన మరణాలను నివేదించలేదని పేర్కొంది.ఈ అంశంపై ఏపీ వైద్య ఆరోగ్య శాఖ అధికారులను బీబీసీ సంప్రదించింది. కేంద్రానికి నివేదించారా లేదా అనే అంశంపై స్పష్టత కోరినప్పటికీ ఆ శాఖ ముఖ్య కార్యదర్శి అనిల్ కుమార్ సింఘాల్, కమిషనర్ కాటంనేని భాస్కర్ స్పందించలేదు. రుయా ఘటనపై కేంద్రానికి అదే రోజు ఏపీ ప్రభుత్వం తరుపున నివేదించామని వైద్య ఆరోగ్య శాఖ ఉన్నతాధికారి ఒకరు బీబీసీకి తెలిపారు. ఆక్సిజన్ ఉంటే మా అమ్మ బతికేదికేవలం తిరుపతి రుయా ఘటన మాత్రమే కాకుండా మే నెల 20వ తేదీ వరకూ ఆంధ్రప్రదేశ్లో కరోనా కేసులు పెరుగుతున్న సమయంలో ఆక్సిజన్ కొరత అనేక చోట్ల కనిపించింది. అనంతపురం ప్రభుత్వాసుపత్రిలోనూ కొందరు ప్రాణాలు కోల్పోయారు. మే 8న ఉదయానికి మా అమ్మకు శ్వాస సమస్య వచ్చింది. ఎంతో ఇబ్బంది పడింది. 108 వాహనానికి ఫోన్ చేస్తే ఓ గంటకి వచ్చింది. ఉదయం 7 గంటల సమయంలో కాకినాడ జీజీహెచ్కి తీసుకెళ్లాం. అప్పటికే చాలా ప్రైవేటు ఆస్పత్రుల కోసం ప్రయత్నం చేశాం. కానీ ఎక్కడా ఆక్సిజన్ బెడ్ దొరకలేదు. జీజీహెచ్కి తీసుకెళ్లిన తర్వాత ఎంపీ వంగా గీతతో సూపరింటెండెంట్కి ఫోన్ చేయించాం. ఆక్సిజన్ బెడ్, వెంటిలేటర్ కూడా ఏర్పాటు చేస్తారని ఆశించాం. కానీ ఆస్పత్రికి వెళ్లేసరికి బెడ్స్ ఖాళీ లేకపోవడంతో మరో మహిళకు వైద్యం అందిస్తున్న బెడ్పై మా అమ్మని పడుకోబెట్టారు. కానీ ఆక్సిజన్ మాత్రం అందలేదు. కొంతసేపు చూశాం. అయినా ఎవరూ స్పందించలేదు. కేకలు వేశాం. డాక్టర్ వచ్చారు. అప్పటికే మా అమ్మకు సమస్య తీవ్రమయిపోయింది. 12 గంటల సమయంలో ఆమె చనిపోయింది. ఆక్సిజన్ సకాలంలో అందించి ఉంటే మా అమ్మ బతికేది. అది లేకపోవడం వల్లనే ఆమె చనిపోయింది. కోవిడ్ వల్ల చనిపోయిందని డెత్ సర్టిఫికెట్ ఇచ్చారు అంటూ తన అనుభవాన్ని బీబీసీతో పంచుకున్నారు. తూర్పు గోదావరి జిల్లా పిఠాపురానికి చెందిన అడబాల రాజబాబు.అడబాల రాజబాబు తల్లి అడబాల సూర్యవతి 57 కాకినాడ ప్రభుత్వ ఆస్పత్రిలో మరణించారు. అవసరమైన స్థాయిలో ఆక్సిజన్ అందించడం ఏప్రిల్ చివరి నుంచి మే నెలలో మొదటి రెండు వారాల పాటు చాలా పెద్ద సమస్య అయ్యింది. కొన్ని ప్రైవేటు ఆస్పత్రుల్లోనూ ఆక్సిజన్ లేకపోవడంతో రోగులను చేర్చుకోలేని స్థితి వచ్చింది.కేవలం కాకినాడలోనే కాకుండా ఆంధ్రప్రదేశ్ వ్యాప్తంగా దాదాపు అన్ని చోట్లా ఇలాంటి పరిస్థితి ఎదురయ్యింది.రాష్ట్రమంతా ఇలాంటి మృతులు అనేక మంది ఉన్నట్టు పలువురు బాధితులు మీడియా సాక్షిగా వాపోయారు. తమ బంధువులకు తగినంత ఆక్సిజన్ అందడం లేదని పలుమార్లు ప్రభుత్వ కాల్ సెంటర్లకు, వివిధ స్థాయిల్లో అధికారులకు ఫిర్యాదులు చేసిన ఘటనలు కోకొల్లలు.ఆంధ్రప్రదేశ్లోనే ఇలాంటి అనుభవాలున్నప్పటికీ దేశమంతా ఆక్సిజన్ కొరతతో ప్రాణాలు కోల్పోయిన వారే లేరని కేంద్రం పార్లమెంట్ సాక్షిగా ప్రకటించడం పలువురుని విస్మయపరుస్తోంది. పైగా రాష్ట్రాలు తమకు నివేదించలేదని పేర్కొనడం మరో చర్చనీయాంశంగా మారింది. ఆక్సిజన్ కోసం ఆరు ఆసుపత్రులు తిరిగాం...ఆక్సిజన్ కొరత వల్ల ఎవరూ చనిపోలేదనడం పచ్చి అబద్ధంతన భార్యకు ఆక్సిజన్ కోసం ఒక్క రాత్రి ఆరు ఆసుపత్రులు తిరిగారు హైదరాబాద్కి చెందిన ముంజులూరి శ్రీనివాస రావు. వెస్ట్ మారేడుపల్లిలో ఉండే ఆయన దాదాపు హైదరాబాద్ నగరం మొత్తం ఆక్సిజన్ కోసం తిరిగారు. అప్పటికే మా ఇంట్లో అందరికీ కరోనా వచ్చింది. మామగారు టిమ్స్లో చేరారు. కానీ అక్కడ ఫుడ్ సరిగా లేదు. భోజనం కాదు కదా మంచినీళ్లు కూడా సరిగా అందక టిమ్స్ నుంచి వచ్చేశారు. ఆయనకు ఇంట్లోనే ఆక్సిజన్ ఏర్పాటు చేశాం. డిపాజిట్, అసలు ధర కలిపి 800 రూపాయల సిలెండర్ పది వేలకు కొన్నాం అంటూ ఆక్సిజన్తో తన మొదటి సమస్య చెప్పారు శ్రీనివాస రావు. తరువాత ఆయన మామగారు చనిపోయారు. కానీ ఈ విషాదం అక్కడితో ముగియలేదు.ఆ తరువాత ఆయన భార్య వంతు వచ్చింది. ఆ రోజు మే 4వ తేదీ. ఆయన భార్య ఆక్సిజన్ స్థాయి తగ్గిపోతుంటే ఆసుపత్రికి తీసుకెళ్లారు. ఏఎస్ రావు నగర్లోని ఒక ప్రైవేటు ఆసుపత్రిలో చేర్చారు. రెండు రోజుల తరువాత ఆ ఆసుపత్రిలో ఆక్సిజన్ కొరత ప్రారంభమైంది. ఆక్సిజన్ సమస్య లేని మంచి వైద్యం అందించే ఆసుపత్రి కోసం వారు ప్రయత్నాలు ప్రారంభించారు.అది మే 6వ తేదీ సాయంత్రం 6.30 గంటలు. అంబులెన్సులో తన భార్యను ఎక్కించి, తాను, కుమారుడు కారులో వెనుకే ఫాలో అవుతూ సోమాజిగూడలోని ఒక ప్రైవేటు ఆసుపత్రికి వెళ్లారు. అప్పటికే ఆ ఆసుపత్రి వారితో ఫోనులో మాట్లాడారు ఆయన. తీరా వెళ్లాక ఆ ఆసుపత్రి వారు చేర్చుకోవడానికి నిరాకరించారు.నేను వాళ్లను బతిమాలాను. నా పోరు పడలేక వాళ్లు నాకు ఒక చోటు చూపించారు. అక్కడ దాదాపు వంద ఖాళీ సిలెండర్లు ఉన్నాయి అని శ్రీనివాస రావు చెప్పారు. అక్కడి నుంచి అల్వాల్లో మరో ఆసుపత్రికి వెళ్లారు. అక్కడా ఆక్సిజన్ లేదన్నారు. అటు నుంచి గాంధీ ఆసుపత్రికి వచ్చారు. గాంధీ ఆసుపత్రికి వెళ్లి చూస్తే అక్కడ క్యూలైన్లో 30 అంబులెన్సులు ఉన్నాయి. వాళ్లందరూ అడ్మిషన్ కోసం ఎదురు చూస్తున్నారు. అక్కడ దాదాపు మూడున్నర గంటలు ఎదురు చూశాం. ఇక లాభం లేదనుకుని, ఎల్బీ నగర్లో వేరే ఆసుపత్రికి వెళ్లాం. అక్కడ కాసేపు ఎదురు చూశాం. వారు పేషెంట్ కండిషన్ చూసి, ఆమెకు 22 లీటర్ల ఆక్సిజన్ కావాలని, తాము అంత అందించలేమని చెప్పేశారు. అక్కడి నుంచి చైతన్యపురిలో వేరే ఆసుపత్రిలో అడ్మిషన్ దొరికింది. సాయంత్రం ఆరున్నరకు బయల్దేరిన మాకు తెల్లవారుఝామను 4.30కి అడ్మిషన్ దొరికింది అని ఆయన చెప్పారు. తన భార్యను ఆస్పత్రిలో చేర్పించి తిరిగివస్తోన్న క్రమంలో శ్రీనివాసరావు కారుకు ప్రమాదం జరిగింది. కారు బాగా దెబ్బతిన్నప్పటికీ వారు స్వల్ప గాయాలతో బయటపడ్డారు.ఆయన భార్య లక్ష్మీ కిరణ్కి 46 సంవత్సరాలు. ఆ రోజు రాత్రి ఆమెకు చాలా సేపు ఆక్సిజన్ అందకపోవడం ఆమె ఆరోగ్యంపై తీవ్ర ప్రభావాన్ని చూపించింది. ఆమె ఆ ఆక్సిజన్ లోటు నుంచి కోలుకోలేకపోయింది. మే 8న ఉదయం పదిన్నరకు ఆమె కన్నుమూశారు.ఆసుపత్రి వారు నాకు ఫోన్ చేశారు. కడసారి చూపునకు రమ్మన్నారు. మేం వెళ్లాం. ఆ పరిస్థితుల్లో ఆమెను చూసి నాకేమీ అర్థం కాలేదు. భయం, బాధ, నిస్సహాయత ఆవరించేశాయి. అన్నేళ్లు నాతో ఉన్న భార్య మరణశయ్యపై ఉంది. తను మమ్మల్ని దగ్గరకు తీసుకోవాలనుకుంది. సాధ్యపడలేదు. మా కళ్లముందే. అంటూ ఆ నాటి పరిస్థితి వివరించారు శ్రీనివాసరావు.మేం పన్నులు కడుతున్నాం. వైద్యం కోసం పది లక్షల వరకు ఖర్చు పెట్టాం. పలుకుబడి లేని మామూలు వ్యక్తికి ఆక్సిజన్ అదించలేకపోవడం కచ్చితంగా ప్రభుత్వ వైఫల్యమే. సామాన్యులకు ఆరోగ్యం అందించలేని పరిస్థితి గురించి ఎవరికి చెప్పాలి? అని ఆయన ప్రశ్నించారు. కేవలం శ్రీనివాసరావు ఒక్కరే కాదు. కరోనా రెండో వేవ్ సమయంలో దేశంలో ఎందరో తీవ్రమైన ఆక్సిజన్ కొరత ఎదుర్కొన్నారు. కరోనా చికిత్స ఇవ్వగలిగి, శరీరం స్పందించి కూడా కేవలం ఆక్సిజన్ దొరక్క మరణించిన వారు చాలా మంది ఉన్నారని వైద్యులు స్వయంగా బీబీసీకి చెప్పారు.హైదరాబాద్లోని ఒక కార్పొరేట్ ఆసుపత్రికి చెందిన ఒక డాక్టర్ బీబీసీతో తన అనుభవాలు పంచుకున్నారు. ఆయన ఒక స్పెషాలిటీ సర్జన్. ప్రైవేటు ఆసుపత్రిలో పనిచేస్తున్నందున తన వివరాలు బయటపెట్టవద్దని కోరారు. జనరల్ మెడిసిన్, పల్మనాలజీ రెండూ కాకపోయినా, కరోనా కేసులు ఎక్కువగా ఉండడంతో ఆయన్ను కూడా డ్యూటీలో వేశారు. ఆక్సిజన్ కొరత స్పష్టంగా ఉంది. మీరు ఆక్సిజన్ తెచ్చుకోగలిగితే, మీరు సొంతంగా ఆక్సిజన్ ఏర్పాటు చేసుకోగలిగితే మిగతా ట్రీట్మెంట్ అంతా మేం ఇస్తామని ఎందరికో చెప్పాం. నేను చికిత్స అందించిన వారిలో కూడా ముగ్గురు చనిపోయారు. వారి మరణానికి ఆక్సిజన్ తగినంత అందుబాటులో లేకపోవడం కూడా కారణమే. ఆక్సిజన్ సిలెండర్ దొరికితే ఆసుపత్రికి కూడా రానక్కర్లేదు. ఇంట్లోనే పెట్టుకోండి అని చికిత్స అందించిన సందర్భాలూ ఉన్నాయి అంటూ ఆ రోజుల్ని గుర్తు చేసుకున్నారు ఆ డాక్టర్. మౌలాలికి చెందిన ఒక పెద్దాయన నా దగ్గరికి వచ్చాడు. ఆయనకు కరోనా నెగిటివ్ వచ్చినప్పటికీ ఆయనకు ఆక్సిజన్ సమస్య వచ్చింది. ప్రైవేటుగా బ్లాక్లో ఆక్సిజన్ కొనడానికి కూడా వారి కుటుంబ సభ్యులు ప్రయత్నం చేశారు. కానీ లాభం లేకపోయింది. వారికి ఆక్సిజన్ అందించలేకపోయారు. ప్రాణం కాపాడలేకపోయాం. ఆ కేసు నాకు వ్యక్తిగతంగా చాలా బాధ కలిగించింది అని ఆయన చెప్పారు. ఆ సమయంలో ఆక్సిజన్ కాన్సన్ట్రేటర్లు కూడా పెద్దగా అందుబాటులో లేవు. ఏ ఆసుపత్రిలోనూ ఆక్సిజన్ బెడ్ ఖాళీలేదు. బ్లాక్లో కొందామన్నా ప్రైవేటు ఆక్సిజన్ సరఫరాదార్లు స్టాక్ లేదని చెప్పేవారు అంటూ చెప్పుకొచ్చారు.కానీ ఆక్సిజన్ తీవ్ర కొరత ఉందని, ఆక్సిజన్ అందక ప్రాణాలు పోతున్నాయని తెలంగాణ ప్రభుత్వం బహిరంగంగా ఒప్పుకోలేదు.ఆక్సిజన్ కొరత లేదనడం ఆశ్చర్యమేకరోనా సెకండ్ వేవ్లో దేశమంతా ఆక్సిజన్ కొరత ఉందన్నది కాదనలేని వాస్తవం. డబ్ల్యూహెచ్ఓ సహా వివిధ దేశాలు కూడా ఈ సమస్య మీద స్పందించాయి. దేశంలో కూడా పారిశ్రామిక సంస్థల నుంచి లిక్విడ్ ఆక్సిజన్ సరఫరా చేశారు. తొలుత ఇంత ముప్పు ఊహించకపోవడంతో అనేక చోట్ల సమస్య ఏర్పడింది. పెద్ద సంఖ్యలోనే ప్రాణాలు కూడా కోల్పోయారు. అయినా కేంద్రం మాత్రం ఆక్సిజన్ కొరత వల్ల ఎవరూ మరణించలేదని పార్లమెంట్లో చెప్పడం ఆశ్చర్యంగా ఉంది. వాస్తవాలను కప్పిపుచ్చే ప్రయత్నంగా కనిపిస్తోంది. ఆక్సిజన్ సరఫరా కోసం గ్రీన్ చానెళ్ల ఏర్పాటు, చివరకు ఎయిర్ లిఫ్టింగ్ కూడా జరిగిన సంగతిని మరచిపోయారా.. ఒక్క ఆక్సిజన్ సిలెండర్ దొరికితే చాలు అన్నట్టుగా వేచి చూడాల్సిన స్థితిని అనుభవించాం. కానీ ఆ ప్రకటన వెనుక ఆంతర్యం ఏమిటన్నది అర్థం కావడం లేదు అంటూ కరోనా రోగులకు చికిత్స అందించిన విజయవాడకు చెందిన డాక్టర్ ఎం చంద్రశేఖర్ బీబీసీతో అన్నారు. source: bbc.comtelugu | telegu |
प्रधानमंत्री मोदी ने 75 प्रतिशत वयस्कों का टीकाकरण पूरा होने पर देशवासियों को बधाई दी नयी दिल्ली, 30 जनवरी भाषा प्रधानमंत्री नरेंद्र मोदी ने देश की वयस्क आबादी में से 75 प्रतिशत का टीकाकरण पूरा होने पर रविवार को देशवासियों को इस महत्वपूर्ण उपलब्धि के लिए बधाई दी और कहा कि उन्हें उन सभी लोगों पर गर्व है, जो टीकाकरण अभियान को सफल बना रहे हैं। केंद्रीय स्वास्थ्य मंत्री मनसुख मांडविया ने ट्वीट कर बताया था कि भारत ने 75 प्रतिशत वयस्क आबादी के कोविड टीकाकरण का लक्ष्य हासिल कर लिया है। प्रधानमंत्री ने मंडाविया के इस ट्वीट को टैग करते हुए ट्विटर पर लिखा, सभी वयस्कों में से 75 प्रतिशत का टीकाकरण पूरा हो चुका है। इस महत्वपूर्ण उपलब्धि के लिये देशवासियों को बधाई। मोदी ने ट्वीट किया, टीकाकरण अभियान को सफल बना रहे सभी लोगों पर गर्व है। भारत में कोविड19 रोधी टीके की अब तक 165.70 करोड़ से अधिक खुराकें दी जा चुकी हैं। भाषा जोहेब अविनाश अविनाश अविनाश | hindi |
சபாநாயகரே விசாரிக்க வேண்டும் பா.நிரோஸ் அண்மையில் சபையில் இடம்பெற்ற கைகலப்பு சம்பவங்கள் தொடர்பில் குழு அமைத்து விசாரணைகளை மேற்கொள்ளாது, சபாநாயகரே நேரடியாக விசாரணைகளை மேற்கொண்டு, உரிய நடவடிக்கை எடுக்க வேண்டும் என தேசிய மக்கள் சக்தியின் தலைவர் அநுரகுமார திஸாநாயக்க தெரிவித்தார். பாராளுமன்றத்தின் நேற்றைய 06 அமர்வில் சபாநாயகரின் அறிவிப்பை தொடர்ந்து உரையாற்றிய பாராளுமன்ற உறுப்பினர் அநுரகுமார திஸாநாயக்க, பாராளுமன்றத்தில் இடம்பெற்ற கைகலப்பு சம்பவங்கள் தொடர்பில் சபாநாயகர் குழு அமைத்து விசாரிப்பதாக கூறுகிறார். ஆனால், இதனை குழு அமைத்து விசாரிக்க வேண்டிய தேவை கிடையாது எனவும் தெரிவித்தார். ஐக்கிய மக்கள் சக்தியின் பாராளுமன்ற உறுப்பினர் மனுஷ நாணயக்காரவை ஆளுங்கட்சியின் உறுப்பினர்கள் சபைக்குள்ளும், சபைக்கு வெளியிலும் தாக்க முயற்சித்ததாகக் கூறி சபாநாயகருக்கு இது தொடர்பில் அறிவித்துள்ளனர் என்றார். பாராளுமன்றத்தில் ஆற்றிய உரையொன்றுக்காக பாராளுமன்றத்திலிருந்து வெளியில் செல்லும்போது மறைந்து கொண்டு செல்ல வேண்டிய நிலை ஏற்பட்டுள்ளது. குறிப்பாக சபாநாயகர் சபைக்கு வரும் நுழைவாயில் வழியாக மறைந்து செல்ல வேண்டிய நிலை ஏற்பட்டுள்ளது. இதனூடாக பாராளுமன்ற உறுப்பினருக்குப் பாதுகாப்பு இல்லை என்பதே வெளிப்படுகிறது என்றார். சபையில் நடைபெறும் பல்வேறு சம்பவங்கள் தொடர்பில் இதற்கு முன்னர் பல குழுக்கள் அமைத்து விசாரிக்கப்பட்டன. எனினும் இந்த விசாரணைகளில் எந்தவிதமான இறுதித் தீர்மானங்களும் எட்டப்பட்டதில்லை. எனவே தற்போது இடம்பெற்றுள்ள இந்த சம்பவத்தையும் குழு அமைத்து விசாரிப்பதனூடாக நியாயம் கிடைக்கப்போவதில்லை எனவும் கூறினார். பாராளுமன்றத்துக்கு வருவதற்கு எம்.பிகள் பயப்படுகிறார்கள். இவ்வாறான நிலையில் பாராளுமன்ற அமர்வுகளை எவ்வாறு நடத்திச் செல்ல முடியும். எம்.பிகளின் பாதுகாப்பு கேள்விக்குறியாகியுள்ளது. இதுதொடர்பில் குழு அமைத்து விசாரிக்கத் தேவையில்லை. சபையில் கமராக்கள் இருக்கின்றன. சபாநாயகரால் இதனை நேரடியாக விசாரிக்க முடியும் என்றார். | tamil |
ప్రపంచానికి చైనా గుబులు లేమాన్ బ్రదర్స్ తరహా ఆర్థిక సంక్షోభం వస్తుందన్న భయాలు న్యూఢిల్లీ, సెప్టెంబర్ 20: కొవిడ్19లా ప్రపంచానికి చైనా నుంచి మరో ముప్పు వచ్చే సంకేతాలు కన్పిస్తున్నాయి. దశాబ్దకాలం క్రితం ప్రపంచ ఆర్థిక వ్యవస్థల్ని కుదిపేసిన లేమాన్ బ్రదర్స్ తరహా సంక్షోభం మరోటి చైనా నుంచి రాబోతుందన్న భయాలు ప్రస్తుతం ఫైనాన్షియల్ మార్కెట్లలో బాగా పెరిగాయి. ఈ ప్రభావంతోనే ఈక్విటీలు, బాండ్లు, వర్థమాన దేశాల కరెన్సీలు ఒక్కసారిగా పతనబాట పట్టాయి. చైనాలో రెండో అతిపెద్ద రియల్టీ కంపెనీ ఎవర్గ్రాండే దివాలా తీస్తుందన్న ఆందోళన మార్కెట్లలో సోమవారం మరీ పెరిగిపోయింది. 305 బిలియన్ డాలర్ల మేర రుణ దాదాపు రూ.23 లక్షల కోట్లు చెల్లింపుల్ని చేయాల్సిఉన్న ఎవర్గ్రాండే ఈ సెప్టెంబర్ 23, 29 తేదీల్లో బాండ్లకు వడ్డీలు చెల్లించాల్సివుంది. ప్రస్తుతం ఉద్యోగులకు జీతాలిచ్చే పరిస్థితిలో కూడా లేని ఎవర్గ్రాండే వచ్చే కొద్దిరోజుల్లో వడ్డీ చెల్లింపుల్లో విఫలమైతే కంపెనీ బాండ్లు డిఫాల్ట్ క్యాటగిరీల్లోకి చేరిపోతాయి. దాంతో ఆ కంపెనీకి రుణాలిచ్చిన ఆర్థిక సంస్థలు, ఫండ్స్ సంక్షోభంలో కూరుకుపోయి, ప్రపంచ మార్కెట్లు, తద్వారా కంపెనీలు అల్లాడిపోతాయి. లేమాన్ బ్రదర్స్ను అమెరికా ప్రభుత్వం ఆదుకోకపోవడంతో ఆ ఇన్వెస్ట్మెంట్ సంస్థ కుప్పకూలి, ప్రపంచ ఆర్థిక వ్యవస్థలను అతలాకుతలం చేసిన పరిణామం ఇప్పుడు మార్కెట్లను కలవరపరుస్తున్నది. ఇండియా స్టీల్ రంగంపై తొలి దెబ్బ.ఎవర్గ్రాండేతో పాటు చైనా రియల్టీ రంగం ఇక్కట్లు ఇండియా స్టీల్ రంగాన్ని తీవ్రంగా ప్రభావితం చేయవచ్చని మార్కెట్ విశ్లేషకులు హెచ్చరిస్తున్నారు. ఈ హెచ్చరికల నేపథ్యంలో సోమవారం టాటా స్టీల్ షేరు 10 శాతం కుప్పకూలింది. వారంరోజులుగా ఈ షేరు 29 శాతం మేర పడిపోయింది. జిందాల్ స్టీల్, జెఎస్డబ్ల్యూ స్టీల్, సెయిల్ తదితర ఉక్కు షేర్లు సైతం అమ్మకాల ఒత్తిడికి లోనయ్యాయి. దేశీ ఉక్కు కంపెనీలు వాటి ఉత్పత్తుల్ని చైనాకు ఎక్కువగా ఎగుమతి చేస్తున్నందున, తాజా సంక్షోభంతో వాటి ఆదాయాలు తగ్గుతాయన్న అంచనాలు నెలకొన్నాయి. ఇనుప ఖనిజాన్ని ఉత్పత్తి చేసే ప్రభుత్వ రంగ ఎన్ఎండీసీ షేరు కూడా తాజాగా 7 శాతం క్షీణించింది. ఇతర మైనింగ్ షేర్లు హిందాల్కో, వేదాంతలు 5 శాతంపైగా నష్టపోయాయి. 1300 రియల్ ఎస్టేట్ ప్రాజెక్టులుచైనాలో కంట్రీ గార్డెన్ హోల్డింగ్స్ తర్వాత ఎవర్గ్రాండే పెద్ద రియల్టీ కంపెనీ. ఇది ఆ దేశంలో 260 నగరాల్లో 1300 రియల్ ఎస్టేట్ ప్రాజెక్టుల్ని ప్రస్తుతం అమలుచేస్తోంది. దాదాపు 15 లక్షల మందికి ఇళ్లు కట్టించిఇవ్వడానికి ప్రజల నుంచి డబ్బు కూడా వసూలుచేసింది. అయితే కొద్ది నెలల నుంచి చైనా రియల్టీ మార్కెట్ మందగించడంతో ఎవర్గ్రాండేపై ప్రభావం పడింది. దాంతో ఉద్యోగులకు జీతాలు, మెటీరియల్ సరఫరా దారులకు బిల్లులు చెల్లించలేని పరిస్థితిలో పడిపోయింది. ఎవర్గ్రాండే బాండ్ల ధరలు కుప్పకూలడంతో పాటు వివిధ చైనా రియల్టీ కంపెనీల బాండ్ల ధరలు కూడా క్షీణించి, వాటి ఈల్డ్స్ బాగా పెరిగాయి. ఈ బాండ్లలో పెట్టుబడిచేసిన బ్లాక్రాక్, యూబీఎస్, గోల్డ్మాన్ శాక్స్ తదితర పలు ప్రపంచ ప్రసిద్ధ ఇన్వెస్ట్మెంట్ ఫండ్స్ ప్రస్తుతం సంకటస్థితిలో పడిపోయాయి. | telegu |
The Prime Minister of Kosovo Ramush Haradinaj appealed to the European Union and the United States of America to help reach the final agreement of mutual recognition between Kosovo and Serbia. He made these comments during promotion of works on Pristina – Mitrovica motorway. He said this road is an arteria which connects economy of the country with neighboring economies, including Serbia.
He said it is Kosovo’s interest to live in a Balkans where everyone is free and where everyone recognizes the other, their borders, their rights.
“In order to reach that day, we will do what is our responsibility, we will build and open bridges, because it is our duty. But we also appeal on the EU and the U.S. to help us on what is not under our capacity, to finally reach an agreement between Kosovo and Serbia for mutual recognition, in order for the entire infrastructure, be it motorways or railways, high transmission of energy which is blocked for more than a decade…so to remove all these obstacles in order for economic and other exchanges to happen freely,” Haradinaj said. | english |
ಕೋವಿಡ್ ಅಳೆಯಿಂದಾಗಿ ತಮಿಳುನಾಡಿನಲ್ಲಿ ಅನಾಥರಾದ 1,400 ಮಕ್ಕಳು ಚೆನ್ನೈ: ಕಳೆದ ವರ್ಷದಿಂದ ಕೋವಿಡ್ 19 ಗೆ ಅನಾಥ ಅಥವಾ ಒಬ್ಬ ಪೋಷಕರನ್ನು ಕಳೆದುಕೊಂಡ ಸುಮಾರು 1,400 ಮಕ್ಕಳನ್ನು ತಮಿಳುನಾಡಿನ ಜಿಲ್ಲಾ ಮಕ್ಕಳ ರಕ್ಷಣಾ ಘಟಕಗಳು ಗುರುತಿಸಿವೆ. ಅನಾಥ ಮಕ್ಕಳು ಅಥವಾ ಕೋವಿಡ್ಗೆ ಒಬ್ಬ ಪೋಷಕರನ್ನು ಕಳೆದುಕೊಂಡ ಮಕ್ಕಳಿಗೆ ಸರ್ಕಾರ 5 ಲಕ್ಷ ರೂ. ಘೋಷಿಸಿದೆ. ಸಾಂಕ್ರಾಮಿಕ ರೋಗವು ಪ್ರಾರಂಭವಾದ 14 ತಿಂಗಳ ಅವಧಿಯಲ್ಲಿ, ದೇಶಾದ್ಯಂತ ಸುಮಾರು 30,000 ಮಕ್ಕಳು ತಮ್ಮ ಹೆತ್ತವರನ್ನು ಮಾರಣಾಂತಿಕವಾಗಿ ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ ಎಂದು ಸುಪ್ರೀಂ ಕೋರ್ಟ್ ಮುಂದೆ ಹಾಜರುಪಡಿಸಿದ ರಾಷ್ಟ್ರೀಯ ಮಕ್ಕಳ ಹಕ್ಕುಗಳ ಸಂರಕ್ಷಣೆ ಎನ್ಸಿಪಿಸಿಆರ್ ವರದಿಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಿತ್ತು. ತಮಿಳುನಾಡಿನ ವಿಷಯದಲ್ಲಿ, ಎನ್ಸಿಪಿಸಿಆರ್ ಅಫಿಡವಿಟ್ನಲ್ಲಿ 802 ಮಕ್ಕಳನ್ನು ಪೋಷಕರು ಮಕ್ಕಳನ್ನು ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ.ಕೋವಿಡ್ ಕುರಿತ ಎಲ್ಲಾ ಲೇಟೆಸ್ಟ್ ಅಪ್ಡೇಟ್ಸ್ ಓದಿ ಆದರೆ ವರದಿಗಳು ಹೊಂದಿಕೆಯಾಗಲಿಲ್ಲ ಏಕೆಂದರೆ ಅನೇಕ ಮಕ್ಕಳನ್ನು ಕಲ್ಯಾಣ ಸಮಿತಿಯ ಮುಂದೆ ಹಾಜರುಪಡಿಸಲಾಗಿಲ್ಲ. ಅನಾಥ ಮಕ್ಕಳಿಗೆ ಅಥವಾ ಒಬ್ಬ ಪೋಷಕರನ್ನು ಕಳೆದುಕೊಂಡವರಿಗೆ ಸಂಬಂಧಿಸಿದ ಸರಿಯಾದ ಮಾಹಿತಿ ನೀಡುವಂತೆ ಸುಪ್ರೀಂ ಕೋರ್ಟ್ ತಮಿಳುನಾಡಿನ ಬಾಲ್ ಸ್ವರಾಜ್ ಪೋರ್ಟಲ್ ವಲಯಕ್ಕೆ ಆದೇಶಿಸಿದೆ. ಕೋವಿಡ್ 19 ಗೆ ಮಕ್ಕಳು ತಮ್ಮ ಹೆತ್ತವರನ್ನು ಕಳೆದುಕೊಳ್ಳುವ ಬಗ್ಗೆ ಮಕ್ಕಳ ಕಲ್ಯಾಣ ಸಮಿತಿಗಳು ಸರಿಯಾದ ವಿವರಗಳನ್ನು ನೀಡಿದಾಗ ಮಾತ್ರ, ಫಲಾನುಭವಿಗಳನ್ನು ಮಕ್ಕಳ ಕಲ್ಯಾಣ ಯೋಜನೆಗಳೊಂದಿಗೆ ಜೋಡಿಸಬಹುದು. ಈ ಎಲ್ಲ ಮಕ್ಕಳಿಗೆ ನಾವು ಸಮಾನವಾಗಿ ಪ್ರಾಮುಖ್ಯತೆ ನೀಡುತ್ತಿದ್ದೇವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಬಯಸುತ್ತೇವೆ ಮತ್ತು ಅವರ ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸಬೇಕಾಗಿದೆ ಎಂದು ಟೈಮ್ಸ್ ಆಫ್ ಇಂಡಿಯಾ ಉಲ್ಲೇಖಿಸಿದಂತೆ ಎನ್ಸಿಪಿಸಿಆರ್ ಅಧ್ಯಕ್ಷ ಪ್ರಿಯಾಂಕ್ ಕನೂಂಗೊ ಹೇಳಿದರು. | kannad |
గృహ రుణాలు తీసుకునే వారికి SBI బంపర్ ఆఫర్.. కొద్దిరోజులు మాత్రమే..! దిశ, వెబ్డెస్క్ : సొంతింటి కల కొందరికీ కలగానే మిగిలిపోతుంది. అందుకు వివిధ కారణాలు ఉండొచ్చు. జీవితకాలంలో చేసే సేవింగ్స్ సరిపోకపోవచ్చు. తమకు నచ్చిన రెడీమేడ్ ఇంటికి మార్కెట్లో ధర ఎక్కువగా ఉండటం, కొత్తగా నిర్మించుకుందామంటే నిర్మాణ ఖర్చులు అధికం అవ్వడం, ఆర్థిక స్థిరత్వం లేకపోవడం, మెడికల్, పిల్లల చదువుల కోసం ఇలా కొందరు తమ సొంతింటి కలను నిజం చేసుకోలేక పదే పదే వాయిదా వేస్తూ వస్తుంటారు. అలాంటి వారికోసం దేశంలోని ప్రభుత్వ రంగ, ప్రైవేట్ సెక్టార్ బ్యాంకులు గృహరుణాలు అందిస్తూ ఎంతో మందికి సొంతింటి కలను సాకారం చేశాయి. ఇటీవల కరోనా ఎఫెక్ట్ ప్రభావం రియల్ ఎస్టేట్ రంగంపై కూడా తీవ్ర ప్రభావం చూపింది.అన్ని కోవిడ్ అప్డేట్స్ గురించి తెలుసుకునేందుకు ఇక్కడ చదవండి చాలా మంది ప్రైవేట్ ఉద్యోగులు రోడ్డున పడ్డారు. ఉన్న సేవింగ్స్ కాస్త మెడికల్ బిల్స్ కే సరిపోగా.. కొందరు రివర్స్లో అప్పులు కూడా చేసేస్థాయికి పడిపోయారు. ఒక్క ఇండియాలోనే కాకుండా ఈ మహమ్మారి తీసుకొచ్చిన మాంద్యం ప్రపంచవ్యాప్తంగా కొనసాగుతోంది. ఇప్పుడిప్పుడే దేశంలో పరిస్థితులు చక్కబడుతుండగా.. తమ కస్టమర్లను అట్రాక్ట్ చేసేందుకు బ్యాంకులు కూడా వివిధ విభాగాల్లో భారీ డిస్కౌంట్ ఆఫర్స్ ప్రకటిస్తున్నాయి. ఈ క్రమంలోనే దేశంలోనే అతిపెద్ద ప్రభుత్వ రంగ బ్యాంకు స్టేట్ బ్యాంక్ ఆఫ్ ఇండియా SBI గృహ రుణాలు తీసుకోవాలనుకునేవారికి శుభవార్త చెప్పింది. హోం లోన్ పై ప్రాసెసింగ్ ఫీజును రద్దు చేస్తున్నట్లు ప్రకటించింది. ఆగస్టు నెలాఖరు వరకు తీసుకునే రుణాలపై మాత్రమే ఈ ఆఫర్ ప్రకటిస్తుందని స్పష్టం చేసింది. ప్రస్తుతం గృహరుణాలపై 0.40 శాతం ప్రాసెసింగ్ ఫీజును SBI వసూలు చేస్తుండగా.. మాన్ సూన్ ధమాకా ఆఫర్ పేరుతో దీనిని రద్దు చేసింది. అంతేకాకుండా SBI ప్రస్తుతం 6.70 శాతం వడ్డీకే గృహరుణాలు అందిస్తుండగా.. యోనో యాప్ ద్వారా దరఖాస్తు చేస్తున్న వారికి 0.05 శాతం అదనంగా వడ్డీ రాయితీని కల్పిస్తున్నట్లు వెల్లడించింది. పెద్ద మొత్తంలో రుణాలు తీసుకునే వారికి SBI ప్రకటించిన ఈ ఆఫర్ ద్వారా భారీ స్థాయిలో లబ్ది చేకూరనుంది. ఇంకెందుకు మరి ఆలస్యం త్వరపడండి.. | telegu |
#include <test/test.hpp>
#include <test/A.h>
#include <falcon/memory/free_list.hpp>
#include "free_list.hpp"
#include "test_allocator.hpp"
#include <sstream>
void free_list_test()
{
std::ostringstream os;
typedef falcon::free_list<A, test_allocator<A> > free_list_type;
free_list_type alloc(1, os);
A * a1 = alloc.alloc();
CHECK_EQUAL_VALUE("alloc\n", os.str());
alloc.free(a1);
A * a2 = alloc.alloc();
CHECK_EQUAL_VALUE("alloc\n", os.str());
A * a3 = alloc.alloc();
CHECK_EQUAL_VALUE("alloc\nalloc\n", os.str());
alloc.free(a2);
A * a4 = alloc.alloc();
CHECK_EQUAL_VALUE("alloc\nalloc\n", os.str());
alloc.free(a4);
alloc.free(a3);
CHECK_EQUAL_VALUE("alloc\nalloc\n", os.str());
free_list_type alloc2(1, os);
alloc2.free(alloc2.alloc());
CHECK_EQUAL_VALUE("alloc\nalloc\nalloc\n", os.str());
alloc.merge(alloc2);
alloc.clear();
CHECK_EQUAL_VALUE("alloc\nalloc\nalloc\ndealloc\ndealloc\ndealloc\n", os.str());
alloc2.clear();
CHECK_EQUAL_VALUE("alloc\nalloc\nalloc\ndealloc\ndealloc\ndealloc\n", os.str());
}
FALCON_TEST_TO_MAIN(free_list_test)
| code |
ശബരിമല മണ്ഡല മകരവിളക്ക് : ക്രമീകരണങ്ങള് വിലയിരുത്താന് 29ന് യോഗം പത്തനംതിട്ട : ശബരിമല മണ്ഡല മകരവിളക്കിനോട് അനുബന്ധിച്ചുള്ള ക്രമീകരണങ്ങള് വിലയിരുത്തുന്നതിനായി ജില്ലാ കളക്ടറുടെ അധ്യക്ഷതയില് ഈ മാസം 29ന് പകല് 11ന് ഓണ് ലൈനായി യോഗം ചേരും.ബന്ധപ്പെട്ട ഉദ്യോഗസ്ഥര് ഇതുവരെ സ്വീകരിച്ച കാര്യങ്ങള് യോഗത്തില് വ്യക്തമാക്കണമെന്ന് ജില്ലാ കളക്ടര് അറിയിച്ചു. കേരളഓണ്ലൈന് വാര്ത്തകള് ടെലിഗ്രാമില് ലഭിക്കാന് ക്ലിക്ക് ചെയ്യുക Also read ശബരിമല മണ്ഡല മകരവിളക്ക് : മുന്നൊരുക്കങ്ങള് വേഗത്തിലാക്കണമെന്ന് പ്രമോദ് നാരായണ് എംഎല്എ ശബരിമല വിമാനത്താവളം ഡിജിസിഎ റിപ്പോര്ട്ടില് തുടര് നടപടികള് ആലോചിക്കാന് സര്ക്കാര് ശബരിമല വിമാനത്താവളം : ചെറുവള്ളി എസ്റ്റേറ്റ് പ്രായോഗികമല്ലെന്ന് ഡി.ജി.സി.എ കേരളഓണ്ലൈന് ന്യൂസ് യൂട്യൂബ് ചാനല് സബ്സ്ക്രൈബ് ചെയ്യാം ശബരിമല മണ്ഡല മകരവിളക്ക് തീര്ഥാടനത്തിനു മുന്നോടിയായി സുരക്ഷിതത്വം ഉറപ്പാക്കുന്നതിനുള്ള നടപടികള് വിലയിരുത്തുന്നതിനായി നടത്തുന്ന സുരക്ഷാ യാത്ര ഒക്ടോബര് ഒന്നിന് നടക്കും.രാവിലെ ഒന്പതിന് പത്തനംതിട്ടയില് നിന്നും പമ്ബയിലേക്കാണ് സുരക്ഷാ യാത്ര നടത്തുക. | malyali |
تَس زاے نہٕ کاوٕ بچہِ تہٕ ہونہِ بچہِ یہِ زَن چانؠو ہُمو بد خصلت زنانو ووٚنُے | kashmiri |
ಬೆಂಗಳೂರು ಸೇರಿದಂತೆ ರಾಜ್ಯದ ಹಲವು ನಗರಗಳಲ್ಲಿ ಎನ್ ಒ2 ಪ್ರಮಾಣ ಹೆಚ್ಚಳ www.karnatakatv.net ಬೆಂಗಳೂರು: ಕೊರೊನಾ ಕಾರಣದಿಂದಾಗಿ ದೇಶಾದ್ಯಂತ ವಿಧಿಸಿದ್ದ ಲಾಕ್ ಡೌನ್ ತೆರವುಗೊಳಿಸುತ್ತಿದ್ದಂತೆ ಬೆಂಗಳೂರು ಸೇರಿದಂತೆ ರಾಜ್ಯದ 12 ನಗರಗಳಲ್ಲಿ ಪರಿಸರ ಮಾಲಿನ್ಯ ಹೆಚ್ಚುತ್ತಿದೆ. ವಾಹನಗಳ ಓಡಾಟ ಹೆಚ್ಚುತ್ತಿದ್ದಂತೆ ಮಾಲಿನ್ಯದ ಪ್ರಮಾಣವೂ ಹೆಚ್ಚುತ್ತಿದೆ. ಮಹಾ ನಗರಗಳಲ್ಲಿ ನೈಟ್ರೋಜನ್ ಡೈ ಆಕ್ಸೈಡ್ ಪ್ರಮಾಣ ಗಣನೀಯವಾಗಿ ಏರಿಕೆ ಕಂಡಿದೆ. ಲಾಕ್ ಡೌನ್ ಅವಧಿಯಲ್ಲಿ ಕಡಿಮೆ ಇದ್ದ ವಾಹನ ಸಂಚಾರ ಏಕಾ ಏಕಿ ಹೆಚ್ಚಿದೆ. ಕಾರ್ಖಾನೆಗಳ ಕೆಲಸ ಆರಂಭವಾಗುತ್ತಿದ್ದಂತೆ ಮಾಲಿನ್ಯದ ಪ್ರಮಾಣವೂ ಗಣನೀಯವಾಗಿ ಏರಿಕೆಯಾಗಿದೆ. ಈ ಕುರಿತು ಗ್ರಿನ್ ಪೀಸ್ ಇಂಡಿಯಾದ ಸಮೀಕ್ಷೆಯಲ್ಲಿ ವರದಿಯಾಗಿದೆ. | kannad |
ગોવા, ઉત્તરાખંડ અને ઉત્તર પ્રદેશમાં પ્રચારપડઘમ શાંત, આવતીકાલે મતદાન યોગી, મોદી, અખિલેશ, પ્રિયંકાએ રેલીઓ યોજીગોવાની તમામ 40, ઉત્તરાખંડની 70 બેઠકો પર જ્યારે ઉત્તર પ્રદેશમાં બીજા તબક્કા માટે 55 બેઠક પર મતદાન થશેબધામાં ભાગલા પાડો અને હળીમળીને લૂંટ ચલાવો તે કોંગ્રેસની નીતિ છે : ઉત્તરાખંડમાં મોદીએ રેલી સંબોધી નવી દિલ્હી : ઉત્તર પ્રદેશ સહિતના પાંચ રાજ્યોમાં વિધાનસભાની ચૂંટણી યોજાવા જઇ રહી છે. એવામાં ઉત્તરાખંડ, ગોવા સહિત યુપીની 55 બેઠકો પરનો ચૂંટણી પ્રચાર થંભી ગયો છે. હવે 14મી તારીખે મતદાન થશે. ઉત્તર પ્રદેશમાં પ્રથમ તબક્કાનું મતદાન પૂર્ણ થઇ ગયું છે જ્યારે બીજા તબક્કા માટે 55 બેઠકો પર મતદાન યોજવામાં આવશે. બીજી તરફ ઉત્તરાખંડની 70 અને ગોવાની 40 બેઠકો પર એક જ તબક્કામાં મતદાન યોજાશે. ઉત્તર પ્રદેશમાં બીજા તબક્કા માટે 55 વિધાનસભા બેઠકો પર ચૂંટણી પ્રચાર થંભી ગયો હતો. ચૂંટણી પ્રચારનો શોર સાંજે પાચ વાગ્યે શાંત પડી ગયો હતો. ઉત્તરાખંડ અને ગોવામાં પણ એક તબક્કામાં મતદાન યોજાશે. જે માટે શનિવારે પ્રચારનો અંતિમ દિન હતો. સાંજે પાંચ વાગ્યે આ બન્ને રાજ્યોમાં પણ ચૂંટણી પ્રચારનો શોર થંભી ગયો હતો. નોંધનીય છે કે ઉત્તર પ્રદેશમાં સાત તબક્કામાં મતદાન યોજાવા જઇ રહ્યું છે. જેમાં પ્રથમ તબક્કાનું 10મીએ જ પૂર્ણ થઇ ગયું હતું જ્યારે બીજા તબક્કામાં 55 બેઠકો માટે 14મી ફેબુ્રઆરીએ મતદાન થશે. ઉત્તરાખંડમાં તમામ 70 અને ગોવાની તમામ 40 બેઠકો પર એક જ તબક્કામાં 14મી ફેબુ્રઆરીએ વોટિંગ યોજવામાં આવશે. ચૂંટણી પ્રચારના અંતિમ દિને અલગ અલગ રાજ્યોમાં રાજકીય પક્ષોએ પ્રચાર કર્યો હતો. અંતિમ દિને પીએમ મોદીએ ઉત્તરાખંડ અને ઉત્તર પ્રદેશમાં રેલીઓ યોજી હતી. જ્યારે કેંદ્રીય ગૃહ મંત્રી અમિત શાહે પણ ઉત્તરાખંડમાં અંતિમ દિને પક્ષના ઉમેદવારો માટે પ્રચાર કર્યો હતો. ઉત્તર પ્રદેશના મુખ્યમંત્રી યોગી આદિત્યનાથે પણ અંતિમ દિને પ્રચાર કર્યો હતો. દરમિયાન વડાપ્રધાન નરેન્દ્ર મોદીએ ઉત્તરાખંડમાં ચૂંટણી પ્રચાર દરમિયાન કોંગ્રેસ પર ભાગલા પાડવાનો આરોપ લગાવ્યો હતો. તેમણે કહ્યું હતું કે કોંગ્રેસની નીતિ બધામાં ફૂટ પાડો, મળીને લૂટ કરો છે. રાજ્યોમાં ચૂંટણી પ્રચારના નિયમો હળવા કરાયાવિવિધ રાજ્યોમાં વિધાનસભાની ચૂંટણીઓ વચ્ચે ચૂંટણી પંચે ચૂંટણી રાજ્યોમાં પદયાત્રાને છૂટ આપી હતી. આ દરમિયાન કોરોના પ્રોટોકોલનું કડકાઇથી પાલન કરવાનો આદેશ પણ આપ્યો હતો. જ્યારે ખુલ્લામાં જાહેર સભાઓમાં બેઠકોની કુલ કેેપેસિટીમાંથી માત્ર 50 ટકા લોકોેને જ હાજર રહેવાની અનુમતી આપવામાં આવી છે. કોરોનાને ધ્યાનમાં રાખીને 8મી જાન્યુઆરીથી પાંચ રાજ્યોમાં રેલીઓ અને સભાઓ પર પ્રતિબંધ મુકવામાં આવ્યો હતો. યુપીમાં બીજા તબક્કામાં આઝમ ખાન સહિતના દિગ્ગજોનો સમાવેશઉત્તર પ્રદેશમાં બીજા તબક્કામાં 14મીએ મતદાન યોજાશે. એવામાં બીજા તબક્કામાં 9 જિલ્લાની 55 બેઠકોને આવરી લેવામાં આવશે. જોકે બીજા તબક્કામાં રાજ્યના અનેક દિગ્ગજ નેતાઓનું ભવિષ્ય પણ ઇવીએમમાં સીલ થવા જઇ રહ્યું છે. જેમાં પૂર્વ મંત્રી ધર્મપાલસિંહ, કમાલ અખ્તર, મેહબૂબ અલી, સપાના દિગ્ગજ નેતા આઝમ ખાનનો પણ સમાવેશ થાય છે. અગાઉ બીજા તબક્કાની આ 55 બેઠકોમાંથી સાત પર ભાજપે ગત વિધાનસભાની ચૂંટણીમાં જીત મેળવી હતી. | gujurati |
ಪಂಜಾಬಿ, ಜಾಟರು ಹೆಚ್ಚು ಬುದ್ದಿವಂತರಲ್ಲ, ಅವರನ್ನು ಬಂಗಾಳಿಗಳಿಗೆ ಹೋಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದ ತ್ರಿಪುರಾ ಮುಖ್ಯಮಂತ್ರಿ ಹೊಸದಿಲ್ಲಿ,ಜು.21: ಪಂಜಾಬಿಗಳು ಹಾಗೂ ಹರ್ಯಾಣದ ಜಾಟರು ದೈಹಿಕವಾಗಿ ಬಲಿಷರಾಗಿದ್ದರೂ ಬಂಗಾಳಿಗಳಷ್ಟು ಬುದ್ದಿವಂತರಲ್ಲ ಎಂದಿರುವ ತ್ರಿಪುರಾದ ಮುಖ್ಯಮಂತ್ರಿ ಬಿಪ್ಲಬ್ ದೇಬ್ ವಿವಾದವನ್ನು ಮೈಮೇಲೆ ಎಳೆದುಕೊಂಡಿದ್ದಾರೆ. ತನ್ನ ಮಾತು ವಿವಾದದ ಸ್ವರೂಪ ಪಡೆಯುತ್ತಲೇ ಎಚ್ಚೆತ್ತುಕೊಂಡ ದೇಬ್ ಕ್ಷಮೆಯಾಚಿಸಿದರು. ರವಿವಾರ ಅಗರ್ತಲದ ಪತ್ರಿಕಾಭವನದಲ್ಲಿ ಮಾತನಾಡುತ್ತಿದ್ದ ದೇಬ್, ಭಾರತದ ಪ್ರತಿಯೊಂದು ಸಮುದಾಯ ನಿರ್ದಿಷ್ಟ ಗುಣಸ್ವಭಾವದಿಂದ ಪ್ರಸಿದ್ಧರಾಗಿದ್ದಾರೆ. ಬುದ್ದಿವಂತಿಕೆಯ ವಿಚಾರದಲ್ಲಿ ಬಂಗಾಳಿಗಳಿಗೆ ಸವಾಲು ಒಡ್ಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ಬುದ್ದಿವಂತಿಕೆಯು ಅವರ ಗುರುತು. ಪಂಜಾಬ್ನಲ್ಲಿ ಸಿಖ್ಖರು ಹಾಗೂ ಹರ್ಯಾಣದಲ್ಲಿ ಜಾಟರು ಜಾಸ್ತಿ ಇದ್ದಾರೆ. ಇವರು ಹೆಚ್ಚು ಬುದ್ದಿವಂತರಲ್ಲ. ಆದರೆ ಪಂಜಾಬಿಗಳು ಶಕ್ತಿಶಾಲಿಗಳು, ಧೈರ್ಯವಂತರು ಹಾಗೂ ಜಾಟರು ಆರೋಗ್ಯವಂತರಾಗಿರುತ್ತಾರೆ. ಅವರನ್ನು ಬಂಗಾಳಿಗಳ ಬುದ್ದಿವಂತಿಕೆಗೆ ಹೋಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಬುದ್ಧಿವಂತಿಕೆಯ ಮೂಲಕ ಇಡೀ ಭಾರತದಲ್ಲಿ ಬಂಗಾಳಿಗಳು ಪ್ರಸಿದ್ದರಾಗಿದ್ದಾರೆ ಎಂದು ದೇಬ್ ಹೇಳಿದ್ದರು. ಮುಖ್ಯಮಂತ್ರಿ ದೇವ್ ಅವರ 50 ಸೆಕೆಂಡ್ಗಳ ವೀಡಿಯೊವನ್ನು ಅನ್ಲೈನ್ನಲ್ಲಿ ಪೋಸ್ಟ್ ಮಾಡಿರುವ ಕಾಂಗ್ರೆಸ್ ವಕ್ತಾರ ರಣದೀಪ್ ಸುರ್ಜೆವಾಲಾ, ಈ ಹೇಳಿಕೆಯು ಬಿಜೆಪಿ ಮನಸ್ಥಿತಿಯ ಸೂಚಕವಾಗಿದೆ ಎಂದು ಆಕ್ರೋಶ ವ್ಯಕ್ತಪಡಿಸಿದರು. ಅವಮಾನಕಾರಿ ಹಾಗೂ ದುರದೃಷ್ಟಕರ. ತ್ರಿಪುರಾದ ಮುಖ್ಯಮಂತ್ರಿ ಬಿಪ್ಲಬ್ ದೇಬ್ ಪಂಜಾಬ್ನ ಸಿಖ್ ಸಹೋದರರು ಹಾಗೂ ಹರ್ಯಾಣದ ಜಾಟ್ ಸಮುದಾಯವನ್ನು ಅವಮಾನಿಸಿದ್ದಾರೆ. ಅವರಿಗೆ ಬುದ್ದಿ ಕಡಿಮೆಯಿದೆ ಎಂದು ಸುರ್ಜೆವಾಲಾ ಟ್ವೀಟ್ ಮಾಡಿದ್ದಾರೆ. ಇದು ಬಿಜೆಪಿಯ ನಿಜವಾದ ಮನಸ್ಥಿತಿ. ಮನೋಹರ್ ಖಟ್ಟರ್ಜೀ ಹಾಗೂ ದುಷ್ಯಂತ್ ಚೌಟಾಲ ಏಕೆ ಮೌನ ತಾಳಿದ್ದಾರೆ ಎಂದು ಹರ್ಯಾಣ ಮುಖ್ಯಮಂತ್ರಿ ಹಾಗೂ ಉಪ ಮುಖ್ಯಮಂತ್ರಿಯನ್ನು ಸುರ್ಜೆವಾಲಾ ಪ್ರಶ್ನಿಸಿದರು. ಪ್ರಧಾನಿ ಮೋದಿಜಿ ಹಾಗೂ ನಡ್ಡಾಜಿಬಿಜೆಪಿ ಅಧ್ಯಕ್ಷ ಎಲ್ಲಿದ್ದಾರೆ?ಇವರು ಕ್ಷಮೆಯಾಚಿಸಿ, ದೇಬ್ ವಿರುದ್ಧ ಕ್ರಮಕೈಗೊಳ್ಳಬೇಕೆಂದರು. ದೇಬ್ ಕ್ಷಮೆಯಾಚನೆ ತ್ರಿಪುರಾ ಸಿಎಂ ದೇಬ್ ತನ್ನ ಆಘಾತಕಾರಿ ಹೇಳಿಕೆಗೆ ಪಂಜಾಬಿ ಹಾಗೂ ಜಾಟ್ ಸಮುದಾಯವನ್ನು ಟ್ವೀಟ್ ಮೂಲಕ ಕ್ಷಮೆಯಾಚಿಸಿದರು. ನನ್ನ ಮಿತ್ರರೆಲ್ಲರೂ ಈ ಎರಡು ಸಮುದಾಯಕ್ಕೆ ಸೇರಿದವರು. ಒಂದು ವೇಳೆ ನನ್ನಹೇಳಿಕೆಯಿಂದ ಯಾರಿಗಾದರೂ ನೋವಾಗಿದ್ದರೆ, ಈ ಕುರಿತು ನಾನು ಕ್ಷಮೆಕೋರುತ್ತೇನೆ ಎಂದು ಸರಣಿ ಟ್ವೀಟ್ನಲ್ಲಿ ದೇಬ್ ಬರೆದುಕೊಂಡಿದ್ದಾರೆ. | kannad |
#include "MCNPInput.hpp"
#include "geometry.hpp"
#include "options.hpp"
#include <stdexcept>
#include <cassert>
#include <iostream>
#include <sstream>
#include <cstdlib>
/******************
* IMPLEMENTATIONS OF DataRef
******************/
template <class T>
class CardRef : public DataRef<T>{
protected:
InputDeck& deck;
DataCard::id_t key;
public:
CardRef( InputDeck& deck_p, DataCard::kind kind, int ident ) :
DataRef<T>(), deck(deck_p), key( std::make_pair( kind, ident ) )
{}
virtual const T& getData() const {
DataCard* c = deck.lookup_data_card( key );
const T& ref = dynamic_cast< DataRef<T>* >(c)->getData();
return ref;
}
virtual CardRef<T> * clone(){
return new CardRef<T>( *this );
}
const DataCard::id_t& getKey() const { return key; }
};
/******************
* HELPER FUNCTIONS
******************/
static void strlower( std::string& str ){
// convert to lowercase
for(size_t i = 0; i < str.length(); ++i){
str[i] = tolower( str.at(i) );
}
}
static int makeint( const std::string& token ){
const char* str = token.c_str();
char* end;
int ret = strtol(str, &end, 10);
if( end != str+token.length() ){
std::cerr << "Warning: string [" << token << "] did not convert to int as expected." << std::endl;
}
return ret;
}
static double makedouble( const std::string& token ){
std::string tmp = token;
// MCNP allows FORTRAN-style floating point values where the 'e' in the exponent is missing,
// e.g. 1.23-45 means 1.23e-45. The following check inserts such a missing 'e' to avoid
// confusing strtod().
size_t s_idx = tmp.find_last_of("+-");
if( s_idx != tmp.npos && s_idx > tmp.find_first_of("1234567890") && tmp.at(s_idx-1) != 'e' ){
tmp.insert( tmp.find_last_of("+-"), "e" );
if( OPT_DEBUG ) std::cout << "Formatting FORTRAN value: converted " << token << " to " << tmp << std::endl;
}
const char* str = tmp.c_str();
char* end;
double ret = strtod(str, &end);
if( end != str+tmp.length() ){
std::cerr << "Warning: string [" << tmp << "] did not convert to double as expected." << std::endl;
}
return ret;
}
/** parse the args of an MCNP geometry transform */
static std::vector<double> makeTransformArgs( const token_list_t tokens ){
std::vector<double> args;
for( token_list_t::const_iterator i = tokens.begin(); i!=tokens.end(); ++i){
std::string token = *i;
size_t idx;
while( (idx = token.find_first_of("()")) != token.npos){
token.replace( idx, 1, "" ); // remove parentheses
}
if( token.find_first_of( "1234567890" ) != token.npos){
args.push_back( makedouble( token ) );
}
else if( token.length() > 0) {
std::cerr << "Warning: makeTransformArgs ignoring unrecognized input token [" << token << "]" << std::endl;
}
}
return args;
}
/**
* Attempt to create a Transform object using the given numbers. Bounding parentheses are allowed
* and will be removed.
*
* The returned object is allocated with new and becomes the property of the caller.
*/
static DataRef<Transform>* parseTransform( InputDeck& deck, const token_list_t tokens, bool degree_format = false ){
std::vector<double> args = makeTransformArgs( tokens );
if( args.size() == 1 ){
return new CardRef<Transform>( deck, DataCard::TR, static_cast<int>(args[0]) );
}
else{
return new ImmediateRef<Transform>( Transform( args, degree_format ) );
}
}
static DataRef<Transform>* parseTransform( InputDeck& deck, token_list_t::iterator& i, bool degree_format = false ){
token_list_t args;
std::string next_token = *i;
if( next_token.find("(") != next_token.npos ){
do{
args.push_back( next_token );
next_token = *(++i);
}
while( next_token.find(")") == next_token.npos );
}
args.push_back( next_token );
return parseTransform( deck, args, degree_format );
}
static FillNode parseFillNode( InputDeck& deck, token_list_t::iterator& i, const token_list_t::iterator& end, bool degree_format = false ){
// simple fill. Format is n or n (transform). Transform may be either a TR card number
// or an immediate transform
int n; // the filling universe
DataRef<Transform>* t;
bool has_transform = false;
std::string first_token = *i;
size_t paren_idx = first_token.find("(");
std::string second_token;
if( paren_idx != first_token.npos ){
// first_token has an open paren
std::string n_str(first_token, 0, paren_idx);
n = makeint(n_str);
second_token = first_token.substr(paren_idx,first_token.npos);
has_transform = true;
}
else{
n = makeint(first_token);
if( ++i != end ){
second_token = *i;
if( second_token[0] == '(' ){
has_transform = true;
}
else{
// the next token didn't belong to this fill
i--;
}
}
else{ i--; }
}
if( has_transform ){
token_list_t transform_tokens;
std::string next_token = second_token;
while( next_token.find(")") == next_token.npos ){
transform_tokens.push_back(next_token);
next_token = *(++i);
}
transform_tokens.push_back( next_token );
t = parseTransform( deck, transform_tokens, degree_format );
}
else{
t = new NullRef<Transform>();
}
if( n < 0 ){
n = -n; // TODO: handle negative universe numbers specially
}
return FillNode (n, t );
}
static bool isblank( const std::string& line ){
return (line=="" || line.find_first_not_of(" ") == line.npos );
}
template < class T >
std::ostream& operator<<( std::ostream& out, const std::vector<T>& list ){
out << "[";
for(typename std::vector<T>::const_iterator i = list.begin(); i!=list.end(); ++i){
out << *i << "|";
}
if(list.size() > 0)
out << "\b"; // unless list was empty, backspace the last | character
out << "]";
return out;
}
/******************
* CELL CARDS
******************/
class CellCardImpl : public CellCard {
protected:
static geom_list_entry_t make_geom_entry(geom_token_t t, int param = 0){
return std::make_pair(t, param);
}
static bool is_num_token( geom_list_entry_t t ){
return t.first == CELLNUM || t.first == SURFNUM || t.first == MBODYFACET;
}
static bool is_op_token( geom_list_entry_t t ){
return t.first == COMPLEMENT || t.first == UNION || t.first == INTERSECT;
}
static int operator_priority( geom_list_entry_t t ){
switch(t.first){
case COMPLEMENT: return 3;
case INTERSECT: return 2;
case UNION: return 1;
default:
throw std::runtime_error("queried operator priority for a non-operator token");
}
}
/**
* Build the geom list as part of cell construction.
* Each item in the list will be a string; either " ", ":", or "#", indicating
* operators, or parentheses, or numbers indicating surface or cell identities.
*
* @param The list of geometry tokens in the input file, as a list of strings that were
* separated by white space in the original file.
*/
void retokenize_geometry( const token_list_t& tokens ){
for(token_list_t::const_iterator i = tokens.begin(); i!=tokens.end(); ++i){
const std::string& token = *i;
size_t j = 0;
while( j < token.length() ){
char cj = token.at(j);
switch(cj){
// the following macro pushes an intersect token onto the geom list
// if the end of that list indicates that one is needed
#define IMPLICIT_INTERSECT() do{ \
if(geom.size()){ \
geom_list_entry_t &t = geom.at(geom.size()-1); \
if( is_num_token(t) || t.first == RPAREN ){ \
geom.push_back( make_geom_entry( INTERSECT ) ); \
}}} while(0)
case '(':
IMPLICIT_INTERSECT();
geom.push_back(make_geom_entry(LPAREN)); j++;
break;
case ')':
geom.push_back(make_geom_entry(RPAREN)); j++;
break;
case '#':
IMPLICIT_INTERSECT();
geom.push_back(make_geom_entry(COMPLEMENT)); j++;
break;
case ':':
geom.push_back(make_geom_entry(UNION)); j++;
break;
default: // a number
// the number refers to a cell if the previous token is a complement
bool is_cell = geom.size() && ((geom.at(geom.size()-1)).first == COMPLEMENT);
IMPLICIT_INTERSECT();
assert(isdigit(cj) || cj == '+' || cj == '-' );
size_t end = token.find_first_not_of("1234567890-+.",j);
assert(j != end);
std::string numstr( token, j, end-j );
const char* numstr_c = numstr.c_str();
char* p;
int num = strtol( numstr_c, &p, 10 );
if( *p == '.' ){
// This is a macrobody facet
assert( !is_cell );
int facet = strtol( p+1, NULL, 10 );
assert( facet > 0 && facet <= 8 );
// storage of macrobody facets: multiply cell number by ten, add facet number
num *= 10;
// don't add a positive facet number to a negative cell numer
num += (num > 0) ? facet : -facet;
geom.push_back( make_geom_entry( MBODYFACET, num ) );
}
else{
geom.push_back( make_geom_entry( is_cell ? CELLNUM : SURFNUM, num ));
}
j += (end-j);
break;
#undef IMPLICIT_INTERSECT
}
}
}
if( OPT_DEBUG ) std::cout << tokens << " -> " << geom << std::endl;
}
/**
* The final step of geometry parsing: convert the geometry list to RPN, which
* greatly simplifies the process of evaluating the geometry later. This function
* uses the shunting yard algorithm. For more info consult
* http://en.wikipedia.org/wiki/Shunting_yard_algorithm
*/
void shunt_geometry( ){
geom_list_t geom_copy( geom );
geom.clear();
geom_list_t stack;
for(geom_list_t::iterator i = geom_copy.begin(); i!=geom_copy.end(); ++i){
geom_list_entry_t token = *i;
if( is_num_token(token) ){
geom.push_back(token);
}
else if( is_op_token(token) ){
while(stack.size()){
geom_list_entry_t& stack_top = stack.back();
if( is_op_token(stack_top) && operator_priority(stack_top) > operator_priority(token) ){
geom.push_back(stack_top);
stack.pop_back();
}
else{
break;
}
}
stack.push_back(token);
}
else if( token.first == LPAREN ){
stack.push_back(token);
}
else if( token.first == RPAREN ){
while( stack.back().first != LPAREN ){
geom.push_back( stack.back() );
stack.pop_back();
}
stack.pop_back(); // remove the LPAREN
}
}
while( stack.size() ){
geom.push_back( stack.back() );
stack.pop_back();
}
}
Vector3d latticeVectorHelper( Vector3d difference_along_normal, Vector3d v_dir ){
double length = difference_along_normal.length() / (difference_along_normal.normalize().dot(v_dir));
return v_dir * length;
}
void setupLattice(){
if( OPT_DEBUG ) std::cout << "Setting up lattice for cell " << ident << std::endl;
std::vector< std::pair<SurfaceCard*,bool> > surfaceCards;
for( geom_list_t::iterator i = geom.begin(); i!=geom.end(); ++i){
geom_list_entry_t entry = *i;
if( entry.first == SURFNUM ){
SurfaceCard* surf = parent_deck.lookup_surface_card( std::abs(entry.second) );
assert(surf);
surfaceCards.push_back( std::make_pair(surf, (entry.second>0) ) );
}
}
int num_finite_dims = 0;
Vector3d v1, v2, v3;
std::vector< std::pair<Vector3d, double> > planes;
if( surfaceCards.size() == 1 ){
planes = surfaceCards.at(0).first->getMacrobodyPlaneParams();
if( surfaceCards.at(0).second != false ){
std::cerr << "Warning: macrobody lattice with positive sense, will proceed as if it was negative.";
}
}
else{
for( unsigned int i = 0; i < surfaceCards.size(); ++i){
planes.push_back( surfaceCards.at(i).first->getPlaneParams() );
if( surfaceCards.at(i).second == true ){ planes[i].first = -planes[i].first; }
}
}
if( OPT_DEBUG ){
for( unsigned int i = 0; i < planes.size(); ++i){
std::cout << " plane " << i << " normal = " << planes[i].first << " d = " << planes[i].second << std::endl;
}
}
if( lat_type == HEXAHEDRAL ){
assert( planes.size() == 2 || planes.size() == 4 || planes.size() == 6 );
if( planes.size() == 2 ){
num_finite_dims = 1;
v1 = planes[0].first.normalize() * std::fabs( planes[0].second - planes[1].second );
}
else if( planes.size() == 4 ){
num_finite_dims = 2;
Vector3d v3 = planes[0].first.cross( planes[2].first ).normalize(); // infer a third (infinite) direction
// vector from planes[1] to planes[0]
Vector3d xv = planes[0].first.normalize() * std::fabs( planes[0].second - planes[1].second );
// direction of l.v1: cross product of normals planes[2] and v3
Vector3d xv2 = planes[2].first.normalize().cross( v3 ).normalize();
v1 = latticeVectorHelper( xv, xv2 );
Vector3d yv = planes[2].first.normalize() * std::fabs( planes[2].second - planes[3].second );
Vector3d yv2 = planes[0].first.normalize().cross( v3 ).normalize();
v2 = latticeVectorHelper( yv, yv2 );
}
else{ // planes.size() == 6
num_finite_dims = 3;
// vector from planes[1] to planes[0]
Vector3d xv = planes[0].first.normalize() * std::fabs( planes[0].second - planes[1].second );
// direction of v1: cross product of normals planes[2] and planes[4]
Vector3d xv2 = planes[2].first.normalize().cross( planes[4].first.normalize() ).normalize();
v1 = latticeVectorHelper( xv, xv2 );
Vector3d yv = planes[2].first.normalize() * std::fabs( planes[2].second - planes[3].second );
Vector3d yv2 = planes[0].first.normalize().cross( planes[4].first.normalize() ).normalize();
v2 = latticeVectorHelper( yv, yv2 );
Vector3d zv = planes[4].first.normalize() * std::fabs( planes[4].second - planes[5].second );
Vector3d zv2 = planes[0].first.normalize().cross( planes[2].first.normalize() ).normalize();
v3 = latticeVectorHelper( zv, zv2 );
}
}
else if( lat_type == HEXAGONAL ){
assert( planes.size() == 6 || planes.size() == 8 );
v3 = planes[0].first.cross( planes[2].first ).normalize(); // prism's primary axis
// vector from planes[1] to planes[0]
Vector3d xv = planes[0].first.normalize() * std::fabs( planes[0].second - planes[1].second );
// direction of l.v1: cross product of normals average(planes[2]+planes[4]) and v3
// TODO: this averaging trick only works with regular hexagons...
Vector3d xv2 = (planes[2].first.normalize()+planes[4].first.normalize()).normalize().cross( v3 ).normalize();
v1 = latticeVectorHelper( xv, xv2 );
Vector3d yv = planes[2].first.normalize() * std::fabs( planes[2].second - planes[3].second );
Vector3d yv2 = (planes[1].first.normalize()+planes[4].first.normalize()).normalize().cross( v3 ).normalize();
v2 = latticeVectorHelper( yv, yv2 );
if( planes.size() == 6 ){
num_finite_dims = 2;
}
else{ // planes.size() == 8
num_finite_dims = 3;
Vector3d zv = planes[6].first.normalize() * std::fabs( planes[6].second - planes[7].second );
Vector3d zv2 = v3;
v3 = latticeVectorHelper( zv, zv2 );
}
}
if( OPT_DEBUG )std::cout << " dims " << num_finite_dims << " vectors " << v1 << v2 << v3 << std::endl;
Lattice l;
if( fill->hasData() ){
l = Lattice( num_finite_dims, v1, v2, v3, fill->getData() );
}
else{
FillNode n( this->universe );
l = Lattice( num_finite_dims, v1, v2, v3, n );
}
lattice = new ImmediateRef<Lattice>( l );
}
void makeData(){
for( token_list_t::iterator i = data.begin(); i!=data.end(); ++i ){
std::string token = *i;
if( token == "trcl" || token == "*trcl" ){
bool degree_format = (token[0] == '*');
i++;
trcl = parseTransform( parent_deck, i, degree_format );
} // token == {*}trcl
else if( token == "u" ){
universe = makeint(*(++i));
} // token == "u"
else if ( token == "lat" ){
int lat_designator = makeint(*(++i));
assert( lat_designator >= 0 && lat_designator <= 2 );
lat_type = static_cast<lattice_type_t>(lat_designator);
if( OPT_DEBUG ) std::cout << "cell " << ident << " is lattice type " << lat_type << std::endl;
}
else if ( token == "mat" ){
material = makeint(*(++i));
}
else if ( token == "rho" ){
rho = makedouble(*(++i));
}
else if ( token.length() == 5 && token.substr(0,4) == "imp:" ){
double imp = makedouble(*(++i));
importances[token[4]] = imp;
}
else if( token == "fill" || token == "*fill" ){
bool degree_format = (token[0] == '*');
std::string next_token = *(++i);
// an explicit lattice grid exists if
// * the next token contains a colon, or
// * the token after it exists and starts with a colon
bool explicit_grid = next_token.find(":") != next_token.npos;
explicit_grid = explicit_grid || (i+1 != data.end() && (*(i+1)).at(0) == ':' );
if( explicit_grid ){
// convert the grid specifiers (x1:x2, y1:y2, z1:z2) into three spaceless strings for easier parsing
std::string gridspec[3];
for( int dim = 0; dim < 3; ++dim ){
std::string spec;
// add tokens to the spec string until it contains a colon but does not end with one
do{
spec += *i;
i++;
}
while( spec.find(":") == spec.npos || spec.at(spec.length()-1) == ':' );
if(OPT_DEBUG) std::cout << "gridspec[" << dim << "]: " << spec << std::endl;
gridspec[dim] = spec;
}
irange ranges[3];
const char* range_str;
char *p;
int num_elements = 1;
for( int dim = 0; dim < 3; ++dim ){
range_str = gridspec[dim].c_str();
ranges[dim].first = strtol(range_str, &p, 10);
ranges[dim].second = strtol(p+1, NULL, 10);
if( ranges[dim].second != ranges[dim].first ){
num_elements *= ( ranges[dim].second - ranges[dim].first )+1;
}
}
std::vector<FillNode> elements;
for( int j = 0; j < num_elements; ++j ){
elements.push_back( parseFillNode( parent_deck, i, data.end(), degree_format ) );
i++;
}
i--;
fill = new ImmediateRef< Fill >( Fill( ranges[0], ranges[1], ranges[2], elements) );
}
else{ // no explicit grid; fill card is a single fill node
FillNode filler = parseFillNode( parent_deck, i, data.end(), degree_format );
fill = new ImmediateRef< Fill >( Fill(filler) );
}
} // token == {*}fill
}
// ensure data pointers are valid
if( !trcl ) {
trcl = new NullRef< Transform >();
}
if( !fill ){
fill = new NullRef< Fill > ();
}
}
int ident;
int material;
double rho; // material density
std::map<char, double> importances;
geom_list_t geom;
token_list_t data;
DataRef<Transform>* trcl;
DataRef<Fill>* fill;
int universe;
bool likenbut;
int likeness_cell_n;
lattice_type_t lat_type;
DataRef<Lattice> *lattice;
public:
CellCardImpl( InputDeck& deck, const token_list_t& tokens ) :
CellCard( deck ), trcl(NULL), fill(NULL), universe(0), likenbut(false), likeness_cell_n(0),
lat_type(NONE), lattice(NULL)
{
unsigned int idx = 0;
ident = makeint(tokens.at(idx++));
if(tokens.at(idx) == "like"){
idx++;
likenbut = true;
likeness_cell_n = makeint(tokens.at(idx++));
idx++; // skip the "but" token
while(idx < tokens.size()){
data.push_back(tokens[idx++]);
}
return;
}
material = makeint(tokens.at(idx++));
rho = 0.0;
if(material != 0){
rho = makedouble(tokens.at(idx++)); // material density
}
token_list_t temp_geom;
// while the tokens appear in geometry-specification syntax, store them into temporary list
while(idx < tokens.size() && tokens.at(idx).find_first_of("1234567890:#-+()") == 0){
temp_geom.push_back(tokens[idx++]);
}
// retokenize the geometry list, which follows a specialized syntax.
retokenize_geometry( temp_geom );
shunt_geometry();
// store the rest of the tokens into the data list
while(idx < tokens.size()){
data.push_back(tokens[idx++]);
}
makeData();
}
~CellCardImpl(){
if(trcl)
delete trcl;
if(fill)
delete fill;
if(lattice)
delete lattice;
}
virtual int getIdent() const{ return ident; }
virtual const geom_list_t getGeom() const { return geom; }
virtual const DataRef<Transform>& getTrcl() const { return *trcl; }
virtual int getUniverse() const { return universe; }
virtual bool hasFill() const { return fill && fill->hasData(); }
virtual const Fill& getFill() const {
if( fill && fill->hasData() ){
return fill->getData();
}
throw std::runtime_error( "Called getFill() on an unfilled cell");
}
virtual bool isLattice() const {
return lat_type != NONE;
}
virtual lattice_type_t getLatticeType() const {
return lat_type;
}
virtual const Lattice& getLattice() const {
if( lattice && lattice->hasData() ){
return lattice->getData();
}
throw std::runtime_error( "Called getLattice() on a cell that hasn't got one" );
}
virtual int getMat() const { return material; }
virtual double getRho() const { return rho; }
virtual const std::map<char,double>& getImportances() const { return importances; }
virtual void print( std::ostream& s ) const{
s << "Cell " << ident << " geom " << geom << std::endl;
}
protected:
void finish(){
if( likenbut ){
CellCardImpl* host = dynamic_cast<CellCardImpl*>(parent_deck.lookup_cell_card( likeness_cell_n ));
if(host->likenbut){
host->finish(); // infinite recursion if cells are circularly defined... but our users wouldn't do that, right?
}
geom = host->geom;
universe = host->universe;
lat_type = host->lat_type;
material = host->material;
rho = host->rho;
importances = host->importances;
if( host->trcl->hasData()){
trcl = host->trcl->clone();
}
if( host->hasFill()){
fill = host->fill->clone();
}
if( host->isLattice()){
lattice = host->lattice->clone();
}
makeData();
likenbut = false;
}
if( lat_type != NONE && lattice == NULL ){
setupLattice();
}
}
friend class InputDeck;
};
CellCard::CellCard( InputDeck& deck ) :
Card(deck)
{}
std::ostream& operator<<(std::ostream& str, const CellCard::geom_list_entry_t& t ){
switch(t.first){
case CellCard::LPAREN: str << "("; break;
case CellCard::RPAREN: str << ")"; break;
case CellCard::COMPLEMENT: str << "#"; break;
case CellCard::UNION: str << ":"; break;
case CellCard::INTERSECT: str << "*"; break;
case CellCard::SURFNUM: str << t.second; break;
case CellCard::CELLNUM: str << "c" << t.second; break;
case CellCard::MBODYFACET:
int cell = t.second / 10;
int facet = abs(t.second) - (abs(cell)*10);
str << cell << "." << facet;
break;
}
return str;
}
/******************
* SURFACE CARDS
******************/
SurfaceCard::SurfaceCard( InputDeck& deck, const token_list_t tokens ):
Card(deck)
{
size_t idx = 0;
std::string token1 = tokens.at(idx++);
if(token1.find_first_of("*+") != token1.npos){
std::cerr << "Warning: no special handling for reflecting or white-boundary surfaces" << std::endl;
token1[0] = ' ';
}
ident = makeint(token1);
std::string token2 = tokens.at(idx++);
if(token2.find_first_of("1234567890-") != 0){
//token2 is the mnemonic
coord_xform = new NullRef<Transform>();
mnemonic = token2;
}
else{
// token2 is a coordinate transform identifier
int tx_id = makeint(token2);
if( tx_id == 0 ){
std::cerr << "I don't think 0 is a valid surface transformation ID, so I'm ignoring it." << std::endl;
coord_xform = new NullRef<Transform>();
}
else if ( tx_id < 0 ){
// abs(tx_id) is the ID of surface with respect to which this surface is periodic.
std::cerr << "Warning: surface " << ident << " periodic, but this program has no special handling for periodic surfaces";
}
else{ // tx_id is positive and nonzero
coord_xform = new CardRef<Transform>( deck, DataCard::TR, makeint(token2) );
}
mnemonic = tokens.at(idx++);
}
while( idx < tokens.size() ){
args.push_back( makedouble(tokens[idx++]) );
}
}
const DataRef<Transform>& SurfaceCard::getTransform() const {
return *coord_xform;
}
void SurfaceCard::print( std::ostream& s ) const {
s << "Surface " << ident << " " << mnemonic << args;
if( coord_xform->hasData() ){
// this ugly lookup returns the integer ID of the TR card
s << " TR" << dynamic_cast<CardRef<Transform>*>(coord_xform)->getKey().second;
}
s << std::endl;
}
std::pair<Vector3d,double> SurfaceCard::getPlaneParams() const {
if(mnemonic == "px"){
return std::make_pair(Vector3d(1,0,0), args[0]);
}
else if(mnemonic == "py"){
return std::make_pair(Vector3d(0,1,0), args[0]);
}
else if(mnemonic == "pz"){
return std::make_pair(Vector3d(0,0,1), args[0]);
}
else if(mnemonic == "p"){
return std::make_pair(Vector3d( args ), args[3]/Vector3d(args).length());
}
else{
throw std::runtime_error("Tried to get plane normal of non-plane surface!");
}
}
std::vector< std::pair<Vector3d, double> > SurfaceCard::getMacrobodyPlaneParams() const {
std::vector< std::pair< Vector3d, double> > ret;
if( mnemonic == "box" ){
Vector3d corner( args );
const Vector3d v[3] = {Vector3d(args,3), Vector3d(args,6), Vector3d(args,9)};
// face order: v1 -v1 v2 -v2 v3 -v3
for( int i = 0; i < 3; ++i ){
Vector3d p = corner + v[i];
ret.push_back( std::make_pair( v[i].normalize(), v[i].projection( p ).length() ) );
ret.push_back( std::make_pair( -v[i].normalize(), v[i].projection( p ).length()-v[i].length() ) );
}
}
else if( mnemonic == "rpp" ){
Vector3d min( args.at(0), args.at(2), args.at(4) );
Vector3d max( args.at(1), args.at(3), args.at(5) );
for( int i = 0; i < 3; ++i ){
Vector3d v; v.v[i] = 1;
ret.push_back( std::make_pair( v.normalize(), max.v[i] ));
ret.push_back( std::make_pair(-v.normalize(), min.v[i] ));
}
}
else if( mnemonic == "hex" || mnemonic == "rhp" ){
Vector3d vertex( args ), height( args,3 ), RV( args, 6 ), SV, TV;
if( args.size() == 9 ){
SV = RV.rotate_about(height, 60); TV = RV.rotate_about(height, 120);
}
else{
SV = Vector3d( args, 9 ); TV = Vector3d( args, 12 );
}
double len = RV.projection( vertex+RV ).length();
ret.push_back( std::make_pair( RV.normalize(), len ) );
ret.push_back( std::make_pair(-RV.normalize(), len - 2.0 * RV.length() ));
len = SV.projection( vertex+SV ).length();
ret.push_back( std::make_pair( SV.normalize(), len ) );
ret.push_back( std::make_pair(-SV.normalize(), len - 2.0 * SV.length() ));
len = TV.projection( vertex+TV ).length();
ret.push_back( std::make_pair( TV.normalize(), len ) );
ret.push_back( std::make_pair(-TV.normalize(), len - 2.0 * TV.length() ));
len = height.projection( vertex+height ).length();
ret.push_back( std::make_pair( height.normalize(), len ) );
ret.push_back( std::make_pair(-height.normalize(), len - height.length() ));
}
else{
throw std::runtime_error("Tried to get macrobody plane normals of unsupported surface!" );
}
return ret;
}
/******************
* DATA CARDS
******************/
class TransformCard : public DataCard, public DataRef<Transform> {
protected:
int ident;
Transform trans;
public:
TransformCard( InputDeck& deck, int ident_p, bool degree_format, const token_list_t& input );
// const Transform& getTransform() const{ return trans; }
const Transform& getData() const{ return trans; }
TransformCard* clone(){ return new TransformCard(*this); }
virtual void print( std::ostream& str );
virtual kind getKind(){ return TR; }
int getIdent() const{ return ident; }
};
TransformCard::TransformCard( InputDeck& deck, int ident_p, bool degree_format, const token_list_t& input ):
DataCard(deck), ident(ident_p), trans( Transform( makeTransformArgs( input ), degree_format ) )
{}
void TransformCard::print( std::ostream& str ){
str << "TR" << ident << ": ";
trans.print(str);
str << std::endl;
}
/******************
* PARSING UTILITIES
******************/
class InputDeck::LineExtractor{
protected:
std::istream& input;
std::string next_line;
bool has_next;
int next_line_idx;
/*
* Take note of the following, from mcnp5 manual page 1-3:
* Tab characters in the input file are converted to one or more blanks, such that the character
* following the tab will be positioned at the next tab stop. Tab stops are set every 8 characters,
* i.e., 9, 17, 25, etc. The limit of input lines to 80 columns applies after tabs are expanded into blank
* spaces. </snip>
* I don't know whether this needs to be addressed to handle corner cases for line continuation, etc.
* currently, it is not addressed.
*/
void get_next(){
bool comment;
do{
if(!std::getline(input, next_line)){
has_next = false;
}
else{
comment = false;
next_line_idx++;
// strip trailing carriage return, if any
if(next_line.length() > 0 && *(next_line.rbegin()) == '\r')
next_line.resize(next_line.size()-1);
// convert to lowercase
strlower(next_line);
// Append a space, to catch blank comment lines (e.g. "c\n") that would otherwise not meet
// the MCNP comment card spec ("a C anywhere in columns 1-5 followed by at least one blank.")
// I have seen lines like "c\n" or " c\n" as complete comment cards in practice, so MCNP must
// accept them.
next_line.append(" ");
// We want to find "c " within the first five
// columns, but not if the c has anything other than a space before it.
size_t idx = next_line.find("c ");
if( idx < 5 ){
if( idx == 0 || next_line.at(idx-1) == ' '){
comment = true;
}
}
}
}
while( has_next && comment );
// iterate until next_line is not a comment line.
}
public:
LineExtractor( std::istream& input_p ) :
input(input_p), next_line("*NO INPUT*"), has_next(true), next_line_idx(0)
{
get_next();
}
const std::string& peekLine() const {
if( has_next ) return next_line;
else throw std::runtime_error("LineExtractor out of lines, cannot peekLine().");
}
const std::string& peekLine( int& lineno ) const {
lineno = next_line_idx;
return peekLine();
}
std::string takeLine() {
if( has_next ){
std::string ret = next_line;
get_next();
return ret;
}
else throw std::runtime_error("LineExtractor out of lines, cannot takeLine().");
}
std::string takeLine( int& lineno ){
lineno = next_line_idx;
return takeLine();
}
bool hasLine() const{
return has_next;
}
/**
* @return the file line number of the next line (as will be returned by either
* peekLine or takeLine)
*/
int getLineCount() const{
return next_line_idx;
}
};
/**
* Append a single token to the given list of tokens.
* The token is assumed to be lowercase, free of comments, and non-blank.
* This function is for handling shortcut
* syntax, e.g. 1 4r, which should translate into four copies of the token 1
*/
void appendToTokenList( const std::string& token, token_list_t& tokens ){
if( token.find_first_of("123456789") == 0 && token.at(token.length()-1) == 'r' ){
// token starts with a number and ends with r: treat as repeat syntax.
const char* string = token.c_str();
char* p;
int num = strtol( string, &p, 10 );
if( (p - string) != static_cast<int>(token.length()) - 1 ){
// oops, this isn't repeat format after all
tokens.push_back(token);
return;
}
if( OPT_DEBUG ) { std::cout << "Repeat syntax: " << token << " repeats "
<< tokens.back() << " " << num << " times." << std::endl; }
for( int i = 0; i < num; ++i){
const std::string& last_tok = tokens.back();
tokens.push_back( last_tok );
}
}
else{
tokens.push_back(token);
}
}
void tokenizeLine( std::string line, token_list_t& tokens, const char* extra_separators = "" ){
// replace any occurances of the characters in extra_separators with spaces;
// they will then act as token separators
size_t found;
found = line.find_first_of(extra_separators);
while (found!= line.npos )
{
line[found] = ' ';
found = line.find_first_of(extra_separators,found+1);
}
std::stringstream str(line);
while(str){
std::string t;
str >> t;
// skip over $-style inline comments
size_t idx;
if((idx = t.find("$")) != t.npos){
if(idx > 0){
// this token had some data before the $
t.resize(idx);
appendToTokenList( t, tokens );
}
break;
}
// if the token is nontrivial, save it
// necessary because stringstream may return a "" at the end of lines.
if(t.length() > 0) appendToTokenList( t, tokens );
}
}
/******************
* INPUT DECK
******************/
InputDeck::~InputDeck(){
for(cell_card_list::iterator i = cells.begin(); i!=cells.end(); ++i){
delete *i;
}
cells.clear();
for(surface_card_list::iterator i = surfaces.begin(); i!=surfaces.end(); ++i){
delete *i;
}
surfaces.clear();
for(data_card_list::iterator i = datacards.begin(); i!=datacards.end(); ++i){
delete *i;
}
datacards.clear();
}
/* handle line continuations: return true if the next line should be treated as part of
* the current line */
bool InputDeck::do_line_continuation( LineExtractor& lines, token_list_t& token_buffer ){
/* check for final character being & */
std::string last_token = token_buffer.at(token_buffer.size()-1);
if( last_token.at(last_token.length()-1) == '&' ){
if( last_token.length() == 1 ){
token_buffer.pop_back();
}
else{
last_token.resize(last_token.length()-1);
token_buffer.at(token_buffer.size()-1).swap( last_token );
}
return true;
}
/* check for next line beginning with five spaces */
else if( lines.hasLine() && lines.peekLine().find(" ") == 0){
/* but don't count it as a continuation if the line is entirely blank */
if( lines.peekLine().find_first_not_of(" \t\n") != std::string::npos ){
return true;
}
}
return false;
}
void InputDeck::parseCells( LineExtractor& lines ){
std::string line;
token_list_t token_buffer;
while( !isblank(line = lines.takeLine()) ){
tokenizeLine(line, token_buffer, "=");
if( do_line_continuation( lines, token_buffer ) ){
continue;
}
if( OPT_DEBUG ) std::cout << "Creating cell with the following tokens:\n" << token_buffer << std::endl;
CellCard* c = new CellCardImpl(*this, token_buffer);
if( OPT_VERBOSE ) c->print(std::cout);
this->cells.push_back(c);
this->cell_map.insert( std::make_pair(c->getIdent(), c) );
token_buffer.clear();
}
}
void InputDeck::parseTitle( LineExtractor& lines ){
// FIXME: will break if the title line looks like a comment card.
int lineno;
std::string topLine = lines.takeLine(lineno);
if(topLine.find("message:") == 0){
if( OPT_VERBOSE ) std::cout << "Skipping MCNP file message block..." << std::endl;
do{
// nothing
}
while( !isblank(lines.takeLine()) ) /*do nothing */;
topLine = lines.takeLine(lineno);
}
if(topLine.find("continue") == 0){
std::cerr << "Warning: this looks like it might be a `continue-run' input file." << std::endl;
std::cerr << " beware of trouble ahead!" << std::endl;
}
std::cout << "The MCNP title card is: " << topLine << std::endl;
//std::cout << " and occupies line " << lineno << std::endl;
}
void InputDeck::parseSurfaces( LineExtractor& lines ){
std::string line;
token_list_t token_buffer;
while( !isblank(line = lines.takeLine()) ){
tokenizeLine(line, token_buffer );
if( do_line_continuation( lines, token_buffer ) ){
continue;
}
SurfaceCard* s = new SurfaceCard(*this, token_buffer);
if( OPT_VERBOSE) s->print(std::cout);
this->surfaces.push_back(s);
this->surface_map.insert( std::make_pair(s->getIdent(), s) );
token_buffer.clear();
}
}
void InputDeck::parseDataCards( LineExtractor& lines ){
std::string line;
token_list_t token_buffer;
while( lines.hasLine() && !isblank(line = lines.takeLine()) ){
tokenizeLine(line, token_buffer );
if( do_line_continuation( lines, token_buffer ) ){
continue;
}
else if( token_buffer.at(0) == "#" ){
std::cerr << "Vertical data card format not supported" << std::endl;
std::cerr << "Data written in this format will be ignored." << std::endl;
}
DataCard* d = NULL;
DataCard::kind t = DataCard::OTHER;
int ident = 0;
std::string cardname = token_buffer.at(0);
token_buffer.erase( token_buffer.begin() );
if( cardname.find("tr") == 0 || cardname.find("*tr") == 0 ){
t = DataCard::TR;
bool degree_format = false;
if( cardname[0] == '*' ){
degree_format = true;
cardname = cardname.substr( 1 ); // remove leading *
}
else if( cardname.find("*") == cardname.length()-1 ){
// although it's undocumented, apparently TRn* is a synonym for *TRn
// (the manual uses this undocumented form in chapter 4)
degree_format = true;
cardname.resize( cardname.length() -1 ); // remove trailing *
}
std::string id_string( cardname, 2 );
// the id_string may be empty, indicating that n is missing from TRn.
// examples from the manual indicate it should be assumed to be 1
if( id_string == "" ){
ident = 1;
}
else{
ident = makeint( id_string );
}
d = new TransformCard( *this, ident, degree_format, token_buffer);
}
if(d){
if( OPT_VERBOSE ){ d->print( std::cout ); }
this->datacards.push_back(d);
this->datacard_map.insert( std::make_pair( std::make_pair(t,ident), d) );
}
token_buffer.clear();
}
}
InputDeck& InputDeck::build( std::istream& input){
LineExtractor lines(input);
InputDeck* deck = new InputDeck();
deck->parseTitle(lines);
deck->parseCells(lines);
deck->parseSurfaces(lines);
deck->parseDataCards(lines);
for( std::vector<CellCard*>::iterator i = deck->cells.begin(); i!=deck->cells.end(); ++i){
dynamic_cast<CellCardImpl*>(*i)->finish();
}
while(lines.hasLine()){ lines.takeLine(); }
if( OPT_VERBOSE ) { std::cout << "Total lines read: " << lines.getLineCount() << std::endl; }
return *deck;
}
InputDeck::cell_card_list InputDeck::getCellsOfUniverse( int universe ){
cell_card_list ret;
for( cell_card_list::iterator i = cells.begin(); i!=cells.end(); ++i){
CellCard* c = *i;
if( std::abs(c->getUniverse()) == universe ){
ret.push_back( *i );
}
}
return ret;
}
CellCard* InputDeck::lookup_cell_card(int ident){
assert( cell_map.find(ident) != cell_map.end() );
return (*cell_map.find(ident)).second;
}
SurfaceCard* InputDeck::lookup_surface_card(int ident){
assert( surface_map.find(ident) != surface_map.end() );
return (*surface_map.find(ident)).second;
}
DataCard* InputDeck::lookup_data_card( const DataCard::id_t& ident ){
assert( datacard_map.find(ident) != datacard_map.end() );
return (*datacard_map.find(ident)).second;
}
| code |
A new breakthrough in concrete by Australian advanced materials technology company, Talga Resources promises to revolutionise a broad range of existing and emerging transport applications.
Talga has achieved high levels of electrical conductivity in concrete by using an additive developed by their graphene-graphite research and development laboratory in the UK.
Given how concrete is the world’s largest construction material by volume (5 billion tonnes/year worth US$450 billion annually), Talga’s graphene-infused electricity-conducting concrete could find use in applications involving underfloor heating, anti-static flooring, EMI shielding, strain sensors, and grounding/ lightning protection.
The technology might also find use in emerging applications such as solid state heated roads, providing an environment-friendly way to clear ice and snow from important transport routes and airport runways. Future applications could include dynamic and wireless charging of electric vehicles while driving.
Based on the initial test results, Talga managing director, Mark Thompson says their graphene-enhanced concrete achieves such high electrical conductivity that it can act like the heating element of an electric stove. When combined with Talga’s thermally conductive concrete, this new type of concrete has some exciting, large volume, scalable and eco-sensitive applications.
The concrete samples were manufactured at Talga’s 100 percent-owned German process test facility and the Betotech (Heidelberg Cement Q&C) laboratory in Germany using industry standard cement along with of Talga’s pristine graphene, graphite and silica-rich by-product of ore processing.
The UoM tests recorded the Talga graphene enhanced concrete as having high electrical conductivity (low resistivity) to 0.05 ohm-cm.
Talga will target value-added graphene and graphite products covering the energy, coatings, composites and construction sectors. Initial customer testing is already underway on lithium-ion batteries and a range of energy storage technologies; metal pre-treatment, marine epoxy and other coatings; cement/concrete additives; and epoxy resins for carbon fibre (composites). | english |
జీజీహెచ్లో సిబ్బంది నియామకానికి చర్యలు: సబ్ కలెక్టర్ క్యాజువాలిటీలో పరిశీలనలో ప్రవీణ్చంద్ విజయవాడ వైద్యం, న్యూస్టుడే: జీజీహెచ్లో ఎఫ్ఎన్ఓఎమ్ఎన్ఓల నియామకానికి చర్యలు చేపడతామని సబ్కలెక్టర్ ప్రవీణ్చంద్ హామీ ఇచ్చారు. ఆయన గురువారం రాత్రి 9:30 గంటలకు ఆస్ప్రతికి వచ్చారు. నేరుగా క్వాజువాలిటీ విభాగంలో రోగుల వద్దకు వెళ్లి వైద్య సేవలపై ఆరా తీశారు. అనంతరం సూపరింటెండెంట్ డాక్టర్ వై.కిరణ్కుమార్, ఇతర అధికారులతో సమావేశమయ్యారు. సిబ్బంది కొరత ఉందని, కనీసం 15 మందిని తక్షణం నియమించాలని అధికారులు విజ్ఞప్తి చేయగా, అందుకు సబ్ కలెక్టర్ సానుకూలంగా స్పందించారు. త్వరలోనే ఎఫ్ఎన్ఓఎమ్ఎన్ఓలను నియమిస్తామని చెప్పారు. పెండింగ్ బిల్లులపై చర్చించారు. త్వరలోనే వాటిని విడుదల చేస్తామని భరోసా ఇచ్చారు. ల్యాబ్లను ఎప్పటికప్పుడు పరిశీలించి, సిబ్బందికి సూచనలు చేయాలని సూపరింటెండెంట్ను ఆదేశించారు. క్వాజువాలిటీ బ్లాక్లో అదనంగా ఏర్పాటు చేస్తున్న 30 పడకలను త్వరితగతిన పూర్తి చేయాలని సూచించారు. అభివృద్ధి పనులపై చర్చించారు. ఆసుపత్రిలోని వివిధ సమస్యలను సూపరింటెండెంట్.. సబ్కలెక్టర్ దృష్టికి తీసుకెళ్లారు. Advertisement | telegu |
شہرٕ کِس دیوارس لَرِ أکِس بٔڈِس مٲدانس منٛز تہٕ تتہِ بادشاہ تہٕ تٔمۍ سٕنٛدؠن وزیرَن ہٕنٛزِ موجوٗدگیہِ منٛز | kashmiri |
/*
Copyright (c) 2015 Seth Pendergrass. See LICENSE.
*/
#include "Animation.h"
#include <cmath>
#include <string>
using namespace std;
using namespace DirectX;
void Animation::SetBindPose(const Skeleton& skeleton, XMMATRIX* transforms) {
for (auto i = 0; i < skeleton.bones.size(); ++i) {
transforms[i] = skeleton.bones[i].local_bind_pose;
}
}
void Animation::Animate(const Skeleton& skeleton, double time,
XMMATRIX* transforms) {
//TODO remove 2 lines:
static const int fps = 24;
time = fmod(time, duration);
for (auto i = 0; i < channels.size(); ++i) {
int frame1 = static_cast<int>(time * fps);
int frame2 = frame1 + 1;
float blend = static_cast<float>(time * fps - frame1) / fps;
XMVECTOR T = XMVectorLerp(XMLoadFloat3(
&channels[i][frame1].translation), XMLoadFloat3(
&channels[i][frame2].translation), blend);
XMVECTOR R = XMQuaternionSlerp(XMLoadFloat4(
&channels[i][frame1].rotation), XMLoadFloat4(
&channels[i][frame2].rotation), blend);
float s1 = channels[i][frame1].scale;
float s2 = channels[i][frame2].scale;
XMVECTOR S = XMVectorLerp(XMVectorSet(s1, s1, s1, 0),
XMVectorSet(s2, s2, s2, 0), blend);
transforms[i] =
XMMatrixAffineTransformation(S, XMQuaternionIdentity(), R, T);
}
}
void Animation::FinalizeAnimation(const Skeleton& skeleton,
XMMATRIX* transforms) {
for (auto i = 0; i < skeleton.bones.size(); ++i) {
if (skeleton.bones[i].parent_index > -1) {
transforms[i] *= transforms[skeleton.bones[i].parent_index];
}
}
for (auto i = 0; i < skeleton.bones.size(); ++i) {
transforms[i] =
skeleton.bones[i].inverse_global_bind_pose * transforms[i];
}
} | code |
<?php
/**
* The template for displaying the footer.
*
* Contains the closing of the id=main div and all content after
*
* @package Gridster
*/
?>
<div id="footer"><?php do_action( 'gridster_credits' ); ?> <?php _e('© Copyright','gridster') ?> <?php the_time('Y') ?> <?php bloginfo('name'); ?>
<a href="http://wordpress.org/" title="<?php esc_attr_e( 'A Semantic Personal Publishing Platform', 'gridster' ); ?>" rel="generator"><?php printf( __( 'Proudly powered by %s', 'gridster' ), 'WordPress' ); ?></a>
<span class="sep"> | </span>
<?php printf( __( 'Theme: %1$s by %2$s.', 'gridster' ), 'Gridster', '<a href="http://themefurnace.com" rel="designer">ThemeFurnace</a>' ); ?></div>
</div><!-- main -->
<?php wp_footer(); ?>
</body>
</html> | code |
ಮಿಥುನ , 22 ಜೂನ್ 2021 ಈ ದಿನವು ನಿಮಗೆ ಸಾಧಾರಣ ದಿನವಾಗಿದೆ ಎಂಬುದಾಗಿ ಗಣೇಶ ಹೇಳುತ್ತಾರೆ. ಹೊಸ ಕಾರ್ಯಗಳ ಮುಂದೂಡುವಿಕೆಯಿಂದಾಗಿ ಉಂಟಾದ ಪ್ರಾರಂಭಿಕ ತೊಡಕುಗಳನ್ನು, ನಿಯಮಿತ ಸಾಮಾಜಿಕ ಸಂವಾದ ಮತ್ತು ಮಕ್ಕಳ ಕುರಿತಾದ ನಿಮ್ಮ ಚಿಂತೆಗಳನ್ನು ಎದುರಿಸಿದ ನಂತರ, ಸಂಜೆಯನ್ನು ನೀವು ಆನಂದಿಸುವಿರಿ. ಮತ್ತು ಇದು ನಿಮಗೆ ಸಮಾಧಾನ ಹಾಗೂ ಶಾಂತಿಯನ್ನು ನೀಡುತ್ತದೆ. ಮನೆಯಲ್ಲಿನ ಸ್ನೇಹಪರ ವಾತಾವರಣವು ಕೆಲವು ಕ್ರಿಯಾತ್ಮಕ ಕಾರ್ಯಗಳನ್ನು ಮಾಡಲು ನಿಮಗೆ ಪ್ರಚೋದನೆ ನೀಡುತ್ತದೆ. ಇಂದು ಸಾಮಾಜಿಕ ಮನ್ನಣೆ ದೊರೆಯಲಿದೆ ಮತ್ತು ಆರ್ಥಿಕ ಲಾಭ ಉಂಟಾಗಲಿದೆ. | kannad |
বিরাট কোহলিকে টেস্ট অধিনায়কত্ব থেকে সরানো স্রেফ সময়ের অপেক্ষা, নতুন নেতাও বেছে নিয়েছে বিসিসিআই টিম ইন্ডিয়ার Team India টেস্ট অধিনায়ক বিরাট কোহলির Virat Kohli খারাপ সময়ের শেষ হচ্ছে না একদিকে গত দুই বছর ধরে ব্যাট হাতে সেঞ্চুরি করতে ব্যর্থ বিরাট, অন্যদিকে এখন দক্ষিণ আফ্রিকায় টেস্ট সিরিজ জয়ের স্বপ্নও চুরমার হয়ে গেছে বিসিসিআই BCCI ইতিমধ্যেই বিরাটকে ওয়ানডে অধিনায়কত্ব থেকে সরিয়ে দিয়েছে, যখন তিনি নিজেই টিটোয়েন্টির অধিনায়কত্ব ছেড়েছেন এই সিরিজ হারের পর বিরাটের টেস্ট অধিনায়কত্ব নিয়েও বড় হুমকি দেখা দিয়েছে নির্বাচকরা বিরাটের পরিবর্তে অন্য খেলোয়াড়ের হাতে অধিনায়কত্ব তুলে দিতে পারেন এই খেলোয়াড়কে নতুন অধিনায়ক করা হবে দক্ষিণ আফ্রিকায় টেস্ট সিরিজ হারের পর বিরাট কোহলির টেস্ট অধিনায়কত্বও যে হুমকির মুখে পড়েছে তাতে কোনো সন্দেহ নেই এই পদের সবচেয়ে বড় প্রতিযোগী হতে পারেন রোহিত শর্মা Rohit Sharma তবে বিসিসিআই প্রতিটি ফরম্যাটের জন্য আলাদা অধিনায়ক চায় এবং এমন পরিস্থিতিতে বিরাটের জায়গায় ২৯ বছর বয়সী কেএল রাহুলকে KL Rahul পরবর্তী অধিনায়ক করা যেতে পারে সম্প্রতি দক্ষিণ আফ্রিকার বিরুদ্ধে দ্বিতীয় টেস্টে দলের অধিনায়কত্ব করেছেন রাহুল রাহুল অসুবিধাগুলিকে ভয় পান না এবং একই সাথে অধিনায়কত্ব তার ব্যাটিংকে প্রভাবিত করে না বিসিসিআইও রাহুলকে পছন্দ করে বিরাটের অনুপস্থিতিতে কেএল রাহুল যেভাবে অধিনায়কত্ব করেছেন, তাতে তিনি সবার মন জয় করেছেন একই সময়ে, রোহিতের ওডিআই সিরিজের বাইরে থাকার পর, বিসিসিআই কেএল রাহুলের হাতে অধিনায়কত্ব হস্তান্তর করে এবং স্পষ্ট করে দেয় যে তিনিও অধিনায়কত্বের জন্য সকলের মনে উপস্থিত রয়েছেন অন্যদিকে, রোহিতকে টেস্ট দলের অধিনায়ক করা ক্ষতিকর কারণ রোহিতের বয়স বর্তমানে ৩৪ বছর এই বয়সে, বেশিরভাগ খেলোয়াড় খেলা থেকে অবসর নেওয়ার পরিকল্পনা করে এমতাবস্থায়, রোহিত বেশিদিন অধিনায়কত্ব সামলাতে পারবেন না এবং বোর্ড তাকে তুলে দেওয়ার ঝুঁকি নিতে চাইবে না একই সময়ে, বিসিসিআই ইতিমধ্যেই স্পষ্ট করে দিয়েছে যে তারাও এখন বাকি বোর্ডগুলির মতো আলাদা ফর্ম্যাটের একজন আলাদা অধিনায়ক চায় | bengali |
అర్ధరాత్రి ఆ ఇంటి గోడల్లో వింత శబ్ధం. పగలగొట్టి చూస్తే. అది 149 ఏళ్లనాటి భవంతి. పురాతన కాలం నాటి ఇల్లు కావడంతో చాలామందికి వాటిపై ఆసక్తి ఉంటుంది. ఎలాగైన చేజిక్కించుకోవాలని అనుకుంటారు. ఇక, పాత ఇల్లు తక్కువ ధరకు వస్తుంది అంతే ఎవరైనా ఎందుకు వదులుకుంటారు చెప్పండి. అందరిలాగే ఆ దంపతులు కూడా పాత ఇంటిని కోనుగోలు చేశారు. కొంతకాలం హ్యాపీగానే గడిచినంది. ప్రశాంతంగా ఉన్నామని అనుకుంటున్న సమయంలో అర్ధరాత్రి వేళ ఇంటి గోడల్లో నుంచి పెద్ద పెద్ద శబ్దలు వినిపించాయి. దాంతో ఆ దంపతులు భయపడిపోయారు. తెల్లారిన వెంటనే స్థానిక పరిశోధనా కేంద్రానికి కాల్ చేశారు. వెంటనే వచ్చి వారు ఆ ఇంటి గోడను బద్దలు కొట్టారు. గోడ పగలగొట్టిన వెంటనే అందులోనుంచి పెద్ద సంఖ్యలో తేనేటీగలు బయటకు వచ్చేశాయి. ఆ గోడ లోపల దాదాపుగా 4 లక్షలకు పైగా తేనెటీగలు ఉన్నాయని తెలియడంతో దంపతులు షాక్ అయ్యారు. ఇంటి ఓనర్ ఈ విషయం చెప్పకుండా తమకు ఇంటిని తక్కువ ధరకు అమ్మేశారని లబోదిబోమంటున్నారు. ఈ సంఘటన అమెరికాలోని పెన్సిల్వేనియాలో జరిగింది. Read: షేరో పూర్తి చేసిన సన్నీ | telegu |
/*
Teem: Tools to process and visualize scientific data and images
Copyright (C) 2011, 2010, 2009, 2008 Thomas Schultz
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public License
(LGPL) as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The terms of redistributing and/or modifying this software also
include exceptions to the LGPL that facilitate static linking.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* This file collects functions that implement extraction of crease
* surfaces as proposed in Schultz / Theisel / Seidel, "Crease
* Surfaces: From Theory to Extraction and Application to Diffusion
* Tensor MRI", IEEE TVCG 16(1):109-119, 2010 */
#include "seek.h"
#include "privateSeek.h"
/* private helper routines for the T-based extraction */
/* Converts a Hessian into the transformed tensor T (cf. paper)
*
* T is a 9-vector representing the output
* evals is a 3-vector (eigenvalues of the Hessian)
* evecs is a 9-vector (eigenvectors of the Hessian)
* evalDiffThresh is the threshold parameter theta (cf. Eq. (4) in paper)
* ridge is non-zero if we are looking for a ridge (zero for valley)
*/
void
_seekHess2T(double *T, const double *evals, const double *evecs,
const double evalDiffThresh, const char ridge) {
double lambdas[3]={0.0,0.0,0.0};
double tmpMat[9], diag[9], evecsT[9];
if (ridge) {
double diff = evals[1]-evals[2];
lambdas[0]=lambdas[1]=1.0;
if (diff<evalDiffThresh)
lambdas[2]=(1.0-diff/evalDiffThresh)*(1.0-diff/evalDiffThresh);
} else {
double diff = evals[0]-evals[1];
lambdas[1]=lambdas[2]=1.0;
if (diff<evalDiffThresh)
lambdas[0]=(1.0-diff/evalDiffThresh)*(1.0-diff/evalDiffThresh);
}
ELL_3M_ZERO_SET(diag);
ELL_3M_DIAG_SET(diag, lambdas[0], lambdas[1], lambdas[2]);
ELL_3M_TRANSPOSE(evecsT, evecs);
ELL_3M_MUL(tmpMat, diag, evecs);
ELL_3M_MUL(T, evecsT, tmpMat);
}
/* Converts a Hessian derivative into a derivative of the transformed
* tensor field T
*
* Tder is a 9-vector representing the output
* hessder is a 9-vector (Hessian derivative)
* evals is a 3-vector (eigenvalues of the Hessian value)
* evecs is a 9-vector (eigenvectors of the Hessian value)
* evalDiffThresh is the threshold parameter theta (cf. Eq. (4) in the paper)
* ridge is non-zero if we are looking for a ridge (zero for valley)
*/
void
_seekHessder2Tder(double *Tder, const double *hessder, const double *evals,
const double *evecs, const double evalDiffThresh,
const char ridge) {
double evecTrans[9];
double hessderE[9]; /* Hessian derivative in eigenframe */
double tmp[9];
ELL_3M_TRANSPOSE(evecTrans,evecs);
ell_3m_mul_d(tmp,hessder,evecTrans);
ell_3m_mul_d(hessderE,evecs,tmp);
if (ridge) {
double diff=evals[1]-evals[2];
double l3;
double l3der;
if (diff<evalDiffThresh)
l3=(1.0-diff/evalDiffThresh)*(1.0-diff/evalDiffThresh);
else l3=0.0;
hessderE[2]*=(1.0-l3)/(evals[0]-evals[2]);
hessderE[6]=hessderE[2];
hessderE[5]*=(1.0-l3)/(evals[1]-evals[2]);
hessderE[7]=hessderE[5];
if (diff<evalDiffThresh)
l3der = 2/evalDiffThresh*(1-diff/evalDiffThresh)*
(hessderE[8]-hessderE[4]);
else
l3der=0;
hessderE[8]=l3der;
hessderE[0]=hessderE[1]=hessderE[3]=hessderE[4]=0.0;
} else {
double diff=evals[0]-evals[1];
double l1;
double l1der;
if (diff<evalDiffThresh)
l1=(1.0-diff/evalDiffThresh)*(1.0-diff/evalDiffThresh);
else l1=0.0;
hessderE[1]*=(l1-1.0)/(evals[0]-evals[1]);
hessderE[3]=hessderE[1];
hessderE[2]*=(l1-1.0)/(evals[0]-evals[2]);
hessderE[6]=hessderE[2];
if (diff<evalDiffThresh)
l1der = 2/evalDiffThresh*(1-diff/evalDiffThresh)*
(hessderE[4]-hessderE[0]);
else
l1der = 0;
hessderE[0]=l1der;
hessderE[4]=hessderE[5]=hessderE[7]=hessderE[8]=0.0;
}
ell_3m_mul_d(tmp,hessderE,evecs);
ell_3m_mul_d(Tder,evecTrans,tmp);
}
static int
findFeatureIntersection(double *results, double *Tleft,
double *hessleft, double *gleft,
double *Tright, double *hessright,
double *gright, double idxleft,
double idxright, char ridge,
const double evalDiffThresh,
const double dotThresh) {
double Tdp = ELL_3V_DOT(Tleft, Tright) + ELL_3V_DOT(Tleft+3,Tright+3) +
ELL_3V_DOT(Tleft+6,Tright+6);
double denom_l = sqrt(ELL_3V_DOT(Tleft, Tleft) + ELL_3V_DOT(Tleft+3, Tleft+3)
+ ELL_3V_DOT(Tleft+6, Tleft+6)),
denom_r = sqrt(ELL_3V_DOT(Tright,Tright) + ELL_3V_DOT(Tright+3, Tright+3)
+ ELL_3V_DOT(Tright+6, Tright+6));
if (Tdp/(denom_l*denom_r)<dotThresh &&
idxright-idxleft>0.24) { /* do a recursive step */
double idxcenter = 0.5*(idxleft+idxright);
/* simply interpolate Hessian linearly */
double hessnew[9];
double evals[3],evecs[9];
double Tnew[9], gradnew[3];
int retval;
ELL_3M_LERP(hessnew,0.5,hessleft,hessright);
ell_3m_eigensolve_d(evals, evecs, hessnew, AIR_TRUE);
_seekHess2T(Tnew, evals, evecs, evalDiffThresh, ridge);
ELL_3V_LERP(gradnew,0.5,gleft,gright);
retval = findFeatureIntersection(results, Tleft, hessleft,
gleft, Tnew, hessnew, gradnew,
idxleft, idxcenter,
ridge, evalDiffThresh, dotThresh);
retval += findFeatureIntersection(results+retval, Tnew, hessnew,
gradnew, Tright, hessright, gright,
idxcenter, idxright,
ridge, evalDiffThresh, dotThresh);
return retval;
} else {
double d1[3], d4[3];
ell_3mv_mul_d(d1, Tleft, gleft);
ELL_3V_SUB(d1,d1,gleft);
ell_3mv_mul_d(d4, Tright, gright);
ELL_3V_SUB(d4,d4,gright);
if (ELL_3V_DOT(d1,d4)<0) { /* mark edge as crossed */
/* find assumed intersection point */
double diff[3], dlen, alpha;
ELL_3V_SUB(diff,d4,d1);
dlen=ELL_3V_LEN(diff);
if (dlen>1e-5) {
double ap=-ELL_3V_DOT(d1,diff)/dlen;
alpha = ap/dlen;
} else
alpha = 0.5;
*results = (1-alpha)*idxleft+alpha*idxright;
return 1;
}
}
return 0;
}
/* Assuming (simplistic) linearly interpolated Hessians and gradients,
* computes the analytical normal of the crease surface.
* The result is _not_ normalized. */
static void
computeGradientLin(double *result, double *T, double *g,
double *Txm, double *gxm, double *Txp, double *gxp,
double *Tym, double *gym, double *Typ, double *gyp,
double *Tzm, double *gzm, double *Tzp, double *gzp) {
double Tder[9];
double gder[3];
double tmp[3], tmp1[3], tmp2[3];
double derxv[3], deryv[3], derzv[3];
ELL_3M_SUB(Tder,Txp,Txm);
ELL_3V_SUB(gder,gxp,gxm);
ell_3mv_mul_d(tmp,T,gder);
ELL_3V_SUB(tmp,tmp,gder);
ell_3mv_mul_d(derxv,Tder,g);
ELL_3V_ADD2(derxv,derxv,tmp);
ELL_3M_SUB(Tder,Typ,Tym);
ELL_3V_SUB(gder,gyp,gym);
ell_3mv_mul_d(tmp,T,gder);
ELL_3V_SUB(tmp,tmp,gder);
ell_3mv_mul_d(deryv,Tder,g);
ELL_3V_ADD2(deryv,deryv,tmp);
ELL_3M_SUB(Tder,Tzp,Tzm);
ELL_3V_SUB(gder,gzp,gzm);
ell_3mv_mul_d(tmp,T,gder);
ELL_3V_SUB(tmp,tmp,gder);
ell_3mv_mul_d(derzv,Tder,g);
ELL_3V_ADD2(derzv,derzv,tmp);
/* accumulate a gradient */
tmp1[0]=derxv[0]; tmp1[1]=deryv[0]; tmp1[2]=derzv[0];
tmp2[0]=derxv[1]; tmp2[1]=deryv[1]; tmp2[2]=derzv[1];
if (ELL_3V_DOT(tmp1,tmp2)<0)
ELL_3V_SCALE(tmp2,-1.0,tmp2);
ELL_3V_ADD2(tmp1,tmp1,tmp2);
tmp2[0]=derxv[2]; tmp2[1]=deryv[2]; tmp2[2]=derzv[2];
if (ELL_3V_DOT(tmp1,tmp2)<0)
ELL_3V_SCALE(tmp2,-1.0,tmp2);
ELL_3V_ADD2(result,tmp1,tmp2);
}
/* Given a unique edge ID and an intersection point given by some value
* alpha \in [0,1], compute the crease surface normal at that point */
static void
computeEdgeGradient(seekContext *sctx, baggage *bag, double *res,
unsigned int xi, unsigned int yi, char edgeid, double alpha)
{
double Txm[9], Txp[9], Tym[9], Typ[9], Tzm[9], Tzp[9], T[9],
gxm[3], gxp[3], gym[3], gyp[3], gzm[3], gzp[3], g[3];
unsigned int sx = AIR_CAST(unsigned int, sctx->sx);
unsigned int sy = AIR_CAST(unsigned int, sctx->sy);
unsigned int sz = AIR_CAST(unsigned int, sctx->sz);
unsigned int si = xi + sx*yi;
unsigned int six = xi + 1 + sx*yi, siX = xi - 1 + sx*yi;
unsigned int siy = xi + sx*(yi+1), siY = xi + sx*(yi-1);
unsigned int sixy = xi + 1 + sx*(yi+1),
sixY = xi + 1 + sx*(yi-1),
siXy = xi - 1 + sx*(yi+1);
/* many special cases needed to fill Txm, gxm, etc. :-( */
switch (edgeid) {
case 0:
ELL_3M_LERP(T, alpha, sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*six));
ELL_3V_LERP(g, alpha, sctx->grad + 3*(0+2*si), sctx->grad + 3*(0+2*six));
ELL_3M_LERP(Tzp, alpha, sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*six));
ELL_3V_LERP(gzp, alpha, sctx->grad + 3*(1+2*si), sctx->grad + 3*(1+2*six));
if (bag->zi==0) {
ELL_3M_COPY(Tzm, T); ELL_3V_COPY(gzm, g);
} else {
ELL_3M_LERP(Tzm, alpha, sctx->tcontext + 9*(0+2*si),
sctx->tcontext + 9*(0+2*six));
ELL_3V_LERP(gzm, alpha, sctx->gradcontext + 3*(0+2*si),
sctx->gradcontext + 3*(0+2*six));
ELL_3M_SCALE(Tzm, 0.5, Tzm); ELL_3M_SCALE(Tzp, 0.5, Tzp);
ELL_3V_SCALE(gzm, 0.5, gzm); ELL_3V_SCALE(gzp, 0.5, gzp);
}
if (yi==0) {
ELL_3M_COPY(Tym, T); ELL_3V_COPY(gym, g);
} else {
ELL_3M_LERP(Tym, alpha, sctx->t + 9*(0+2*siY), sctx->t + 9*(0+2*sixY));
ELL_3V_LERP(gym, alpha, sctx->grad + 3*(0+2*siY),
sctx->grad + 3*(0+2*sixY));
}
if (yi==sy-1) {
ELL_3M_COPY(Typ, T); ELL_3V_COPY(gyp, g);
} else {
ELL_3M_LERP(Typ, alpha, sctx->t + 9*(0+2*siy), sctx->t + 9*(0+2*sixy));
ELL_3V_LERP(gyp, alpha, sctx->grad + 3*(0+2*siy),
sctx->grad + 3*(0+2*sixy));
}
if (yi!=0 && yi!=sy-1) {
ELL_3M_SCALE(Tym, 0.5, Tym); ELL_3M_SCALE(Typ, 0.5, Typ);
ELL_3V_SCALE(gym, 0.5, gym); ELL_3V_SCALE(gyp, 0.5, gyp);
}
computeGradientLin(res, T, g,
sctx->t + 9*(0+2*si), sctx->grad + 3*(0+2*si),
sctx->t + 9*(0+2*six), sctx->grad + 3*(0+2*six),
Tym, gym, Typ, gyp,
Tzm, gzm, Tzp, gzp);
break;
case 1:
ELL_3M_LERP(T, alpha, sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*siy));
ELL_3V_LERP(g, alpha, sctx->grad + 3*(0+2*si), sctx->grad + 3*(0+2*siy));
ELL_3M_LERP(Tzp, alpha, sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gzp, alpha, sctx->grad + 3*(1+2*si), sctx->grad + 3*(1+2*siy));
if (bag->zi==0) {
ELL_3M_COPY(Tzm, T); ELL_3V_COPY(gzm, g);
} else {
ELL_3M_LERP(Tzm, alpha, sctx->tcontext + 9*(0+2*si),
sctx->tcontext + 9*(0+2*siy));
ELL_3V_LERP(gzm, alpha, sctx->gradcontext + 3*(0+2*si),
sctx->gradcontext + 3*(0+2*siy));
ELL_3M_SCALE(Tzm, 0.5, Tzm); ELL_3M_SCALE(Tzp, 0.5, Tzp);
ELL_3V_SCALE(gzm, 0.5, gzm); ELL_3V_SCALE(gzp, 0.5, gzp);
}
if (xi==0) {
ELL_3M_COPY(Txm, T); ELL_3V_COPY(gxm, g);
} else {
ELL_3M_LERP(Txm, alpha, sctx->t + 9*(0+2*siX), sctx->t + 9*(0+2*siXy));
ELL_3V_LERP(gxm, alpha, sctx->grad + 3*(0+2*siX),
sctx->grad + 3*(0+2*siXy));
}
if (xi==sx-1) {
ELL_3M_COPY(Txp, T); ELL_3V_COPY(gxm, g);
} else {
ELL_3M_LERP(Txp, alpha, sctx->t + 9*(0+2*six), sctx->t + 9*(0+2*sixy));
ELL_3V_LERP(gxp, alpha, sctx->grad + 3*(0+2*six),
sctx->grad + 3*(0+2*sixy));
}
if (xi!=0 && xi!=sx-1) {
ELL_3M_SCALE(Txm, 0.5, Txm); ELL_3M_SCALE(Txp, 0.5, Txp);
ELL_3V_SCALE(gxm, 0.5, gxm); ELL_3V_SCALE(gxp, 0.5, gxp);
}
computeGradientLin(res, T, g,
Txm, gxm, Txp, gxp,
sctx->t + 9*(0+2*si), sctx->grad + 3*(0+2*si),
sctx->t + 9*(0+2*siy), sctx->grad + 3*(0+2*siy),
T, g, Tzp, gzp);
break;
case 2:
ELL_3M_LERP(T, alpha, sctx->t + 9*(0+2*si), sctx->t + 9*(1+2*si));
ELL_3V_LERP(g, alpha, sctx->grad + 3*(0+2*si), sctx->grad + 3*(1+2*si));
if (xi==0) {
ELL_3M_COPY(Txm, T); ELL_3V_COPY(gxm, g);
} else {
ELL_3M_LERP(Txm, alpha, sctx->t + 9*(0+2*siX), sctx->t + 9*(1+2*siX));
ELL_3V_LERP(gxm, alpha, sctx->grad + 3*(0+2*siX),
sctx->grad + 3*(1+2*siX));
}
if (xi==sx-1) {
ELL_3M_COPY(Txp, T); ELL_3V_COPY(gxp, g);
} else {
ELL_3M_LERP(Txp, alpha, sctx->t + 9*(0+2*six), sctx->t + 9*(1+2*six));
ELL_3V_LERP(gxp, alpha, sctx->grad + 3*(0+2*six),
sctx->grad + 3*(1+2*six));
}
if (xi!=0 && xi!=sx-1) {
ELL_3M_SCALE(Txm, 0.5, Txm); ELL_3M_SCALE(Txp, 0.5, Txp);
ELL_3V_SCALE(gxm, 0.5, gxm); ELL_3V_SCALE(gxp, 0.5, gxp);
}
if (yi==0) {
ELL_3M_COPY(Tym, T); ELL_3V_COPY(gym, g);
} else {
ELL_3M_LERP(Tym, alpha, sctx->t + 9*(0+2*siY), sctx->t + 9*(1+2*siY));
ELL_3V_LERP(gym, alpha, sctx->grad + 3*(0+2*siY),
sctx->grad + 3*(1+2*siY));
}
if (yi==sy-1) {
ELL_3M_COPY(Typ, T); ELL_3V_COPY(gyp, g);
} else {
ELL_3M_LERP(Typ, alpha, sctx->t + 9*(0+2*siy), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gyp, alpha, sctx->grad + 3*(0+2*siy),
sctx->grad + 3*(1+2*siy));
}
if (yi!=0 && yi!=sy-1) {
ELL_3M_SCALE(Tym, 0.5, Tym); ELL_3M_SCALE(Typ, 0.5, Typ);
ELL_3V_SCALE(gym, 0.5, gym); ELL_3V_SCALE(gyp, 0.5, gyp);
}
if (bag->zi>0 && bag->zi<sz-2) {
ELL_3M_LERP(Tzm, alpha, sctx->tcontext + 9*(0+2*si),
sctx->t + 9*(0+2*si));
ELL_3V_LERP(gzm, alpha, sctx->gradcontext + 3*(0+2*si),
sctx->grad + 3*(0+2*si));
ELL_3M_LERP(Tzp, alpha, sctx->t + 9*(1+2*si),
sctx->tcontext + 9*(1+2*si));
ELL_3V_LERP(gzp, alpha, sctx->grad + 3*(1+2*si),
sctx->gradcontext + 3*(1+2*si));
ELL_3M_SCALE(Tzm, 0.5, Tzm); ELL_3M_SCALE(Tzp, 0.5, Tzp);
ELL_3V_SCALE(gzm, 0.5, gzm); ELL_3V_SCALE(gzp, 0.5, gzp);
} else {
ELL_3M_COPY(Tzm, sctx->t + 9*(0+2*si));
ELL_3V_COPY(gzm, sctx->grad + 3*(0+2*si));
ELL_3M_COPY(Tzp, sctx->t + 9*(1+2*si));
ELL_3V_COPY(gzp, sctx->grad + 3*(1+2*si));
}
computeGradientLin(res, T, g,
Txm, gxm, Txp, gxp,
Tym, gym, Typ, gyp,
Tzm, gzm, Tzp, gzp);
break;
case 3:
ELL_3M_LERP(T, alpha, sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*six));
ELL_3V_LERP(g, alpha, sctx->grad + 3*(1+2*si), sctx->grad + 3*(1+2*six));
ELL_3M_LERP(Tzm, alpha, sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*six));
ELL_3V_LERP(gzm, alpha, sctx->grad + 3*(0+2*si), sctx->grad + 3*(0+2*six));
if (bag->zi==sz-2) {
ELL_3M_COPY(Tzp, T); ELL_3V_COPY(gzp, g);
} else {
ELL_3M_LERP(Tzp, alpha, sctx->tcontext + 9*(1+2*si),
sctx->tcontext + 9*(1+2*six));
ELL_3V_LERP(gzp, alpha, sctx->gradcontext + 3*(1+2*si),
sctx->gradcontext + 3*(1+2*six));
ELL_3M_SCALE(Tzm, 0.5, Tzm); ELL_3M_SCALE(Tzp, 0.5, Tzp);
ELL_3V_SCALE(gzm, 0.5, gzm); ELL_3V_SCALE(gzp, 0.5, gzp);
}
if (xi>0 && xi<sx-2) {
unsigned int siX = xi - 1 + sx*yi;
unsigned int sixx = xi + 2 + sx*yi;
ELL_3M_LERP(Txm, alpha, sctx->t + 9*(1+2*siX), sctx->t + 9*(1+2*si));
ELL_3V_LERP(gxm, alpha, sctx->grad + 3*(1+2*siX),
sctx->grad + 3*(1+2*si));
ELL_3M_LERP(Txp, alpha, sctx->t + 9*(1+2*six), sctx->t + 9*(1+2*sixx));
ELL_3V_LERP(gxp, alpha, sctx->grad + 3*(1+2*six),
sctx->grad + 3*(1+2*sixx));
ELL_3M_SCALE(Txm, 0.5, Txm); ELL_3M_SCALE(Txp, 0.5, Txp);
ELL_3V_SCALE(gxm, 0.5, gxm); ELL_3V_SCALE(gxp, 0.5, gxp);
} else {
ELL_3M_COPY(Txm, sctx->t + 9*(1+2*si));
ELL_3V_COPY(gxm, sctx->grad + 3*(1+2*si));
ELL_3M_COPY(Txp, sctx->t + 9*(1+2*six));
ELL_3V_COPY(gxp, sctx->grad + 3*(1+2*six));
}
if (yi==0) {
ELL_3M_COPY(Tym, T); ELL_3V_COPY(gym, g);
} else {
ELL_3M_LERP(Tym, alpha, sctx->t + 9*(1+2*siY), sctx->t + 9*(1+2*sixY));
ELL_3V_LERP(gym, alpha, sctx->grad + 3*(1+2*siY),
sctx->grad + 3*(1+2*sixY));
}
if (yi==sy-1) {
ELL_3M_COPY(Typ, T); ELL_3V_COPY(gyp, g);
} else {
ELL_3M_LERP(Typ, alpha, sctx->t + 9*(1+2*siy), sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gyp, alpha, sctx->grad + 3*(1+2*siy),
sctx->grad + 3*(1+2*sixy));
}
if (yi!=0 && yi!=sy-1) {
ELL_3M_SCALE(Tym, 0.5, Tym); ELL_3M_SCALE(Typ, 0.5, Typ);
ELL_3V_SCALE(gym, 0.5, gym); ELL_3V_SCALE(gyp, 0.5, gyp);
}
computeGradientLin(res, T, g,
Txm, gxm, Txp, gxp,
Tym, gym, Typ, gyp,
Tzm, gzm, Tzp, gzp);
break;
case 4:
ELL_3M_LERP(T, alpha, sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(g, alpha, sctx->grad + 3*(1+2*si), sctx->grad + 3*(1+2*siy));
ELL_3M_LERP(Tzm, alpha, sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*siy));
ELL_3V_LERP(gzm, alpha, sctx->grad + 3*(0+2*si), sctx->grad + 3*(0+2*siy));
if (bag->zi==sz-2) {
ELL_3M_COPY(Tzp, T); ELL_3V_COPY(gzp, g);
} else {
ELL_3M_LERP(Tzp, alpha, sctx->tcontext + 9*(1+2*si),
sctx->tcontext + 9*(1+2*siy));
ELL_3V_LERP(gzp, alpha, sctx->gradcontext + 3*(1+2*si),
sctx->gradcontext + 3*(1+2*siy));
ELL_3M_SCALE(Tzm, 0.5, Tzm); ELL_3M_SCALE(Tzp, 0.5, Tzp);
ELL_3V_SCALE(gzm, 0.5, gzm); ELL_3V_SCALE(gzp, 0.5, gzp);
}
if (xi==0) {
ELL_3M_COPY(Txm, T); ELL_3V_COPY(gxm, g);
} else {
ELL_3M_LERP(Txm, alpha, sctx->t + 9*(1+2*siX), sctx->t + 9*(1+2*siXy));
ELL_3V_LERP(gxm, alpha, sctx->grad + 3*(1+2*siX),
sctx->grad + 3*(1+2*siXy));
}
if (xi==sx-1) {
ELL_3M_COPY(Txp, T); ELL_3V_COPY(gxp, g);
} else {
ELL_3M_LERP(Txp, alpha, sctx->t + 9*(1+2*six), sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gxp, alpha, sctx->grad + 3*(1+2*six),
sctx->grad + 3*(1+2*sixy));
}
if (xi!=0 && xi!=sx-1) {
ELL_3M_SCALE(Txm, 0.5, Txm); ELL_3M_SCALE(Txp, 0.5, Txp);
ELL_3V_SCALE(gxm, 0.5, gxm); ELL_3V_SCALE(gxp, 0.5, gxp);
}
if (yi>0 && yi<sy-2) {
unsigned int siY = xi + sx*(yi-1);
unsigned int siyy = xi + sx*(yi+2);
ELL_3M_LERP(Tym, alpha, sctx->t + 9*(1+2*siY), sctx->t + 9*(1+2*si));
ELL_3V_LERP(gym, alpha, sctx->grad + 3*(1+2*siY),
sctx->grad + 3*(1+2*si));
ELL_3M_LERP(Typ, alpha, sctx->t + 9*(1+2*siy), sctx->t + 9*(1+2*siyy));
ELL_3V_LERP(gyp, alpha, sctx->grad + 3*(1+2*siy),
sctx->grad + 3*(1+2*siyy));
ELL_3M_SCALE(Tym, 0.5, Tym); ELL_3M_SCALE(Typ, 0.5, Typ);
ELL_3V_SCALE(gym, 0.5, gym); ELL_3V_SCALE(gyp, 0.5, gyp);
} else {
ELL_3M_COPY(Tym, sctx->t + 9*(1+2*si));
ELL_3V_COPY(gym, sctx->grad + 3*(1+2*si));
ELL_3M_COPY(Typ, sctx->t + 9*(1+2*six));
ELL_3V_COPY(gyp, sctx->grad + 3*(1+2*six));
}
computeGradientLin(res, T, g,
Txm, gxm, Txp, gxp,
Tym, gym, Typ, gyp,
Tzm, gzm, Tzp, gzp);
break;
}
}
/* Given a unique face ID and coordinates, compute the crease surface
* normal at the specified degenerate point */
static void
computeFaceGradient(seekContext *sctx, double *res,
unsigned int xi, unsigned int yi,
char faceid, double *coords) {
double T[9], Txm[9], Txp[9], Tym[9], Typ[9], Tzm[9], Tzp[9],
g[3], gxm[3], gxp[3], gym[3], gyp[3], gzm[3], gzp[3];
unsigned int sx = AIR_CAST(unsigned int, sctx->sx);
unsigned int sy = AIR_CAST(unsigned int, sctx->sy);
unsigned int si = xi + sx*yi;
unsigned int six = xi + 1 + sx*yi, siX = xi - 1 + sx*yi;
unsigned int siy = xi + sx*(yi+1), siY = xi + sx*(yi-1);
unsigned int sixy = xi + 1 + sx*(yi+1), sixY = xi + 1 + sx*(yi-1),
siXy = xi - 1 + sx*(yi+1);
/* Again, lots of special cases to fill Txm, gxm, etc. */
switch (faceid) {
case 0:
/* bilinearly interpolate Tzp/gzp first */
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(1+2*si),
sctx->grad + 3*(1+2*siy));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(1+2*six), sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(1+2*six),
sctx->grad + 3*(1+2*sixy));
ELL_3M_LERP(Tzp, coords[0], Txm, Txp);
ELL_3V_LERP(gzp, coords[0], gxm, gxp);
/* now, compute all required points on the bottom face */
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*siy));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(0+2*siy));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(0+2*six), sctx->t + 9*(0+2*sixy));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(0+2*six),
sctx->grad + 3*(0+2*sixy));
ELL_3M_LERP(Tym, coords[0], sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*six));
ELL_3V_LERP(gym, coords[0], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(0+2*six));
ELL_3M_LERP(Typ, coords[0], sctx->t + 9*(0+2*siy), sctx->t + 9*(0+2*sixy));
ELL_3V_LERP(gyp, coords[0], sctx->grad + 3*(0+2*siy),
sctx->grad + 3*(0+2*sixy));
ELL_3M_LERP(T, coords[0], Txm, Txp);
ELL_3V_LERP(g, coords[0], gxm, gxp);
computeGradientLin(sctx->facenorm+3*(faceid+4*si), T, g,
Txm, gxm, Txp, gxp,
Tym, gym, Typ, gyp,
T, g, Tzp, gzp);
break;
case 1:
/* bilinearly interpolate Typ/gyp first */
if (yi!=sy-1) {
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(0+2*siy), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(0+2*siy),
sctx->grad + 3*(1+2*siy));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(0+2*sixy),
sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(0+2*sixy),
sctx->grad + 3*(1+2*sixy));
ELL_3M_LERP(Typ, coords[0], Txm, Txp);
ELL_3V_LERP(gyp, coords[0], gxm, gxp);
} else {
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(0+2*siY), sctx->t + 9*(1+2*siY));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(0+2*siY),
sctx->grad + 3*(1+2*siY));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(0+2*sixY),
sctx->t + 9*(1+2*sixY));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(0+2*sixY),
sctx->grad + 3*(1+2*sixY));
ELL_3M_LERP(Tym, coords[0], Txm, Txp);
ELL_3V_LERP(gym, coords[0], gxm, gxp);
}
/* now, compute remaining points */
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(0+2*si), sctx->t + 9*(1+2*si));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(1+2*si));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(0+2*six), sctx->t + 9*(1+2*six));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(0+2*six),
sctx->grad + 3*(1+2*six));
ELL_3M_LERP(Tzm, coords[0], sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*six));
ELL_3V_LERP(gzm, coords[0], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(0+2*six));
ELL_3M_LERP(Tzp, coords[0], sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*six));
ELL_3V_LERP(gzp, coords[0], sctx->grad + 3*(1+2*si),
sctx->grad + 3*(1+2*six));
ELL_3M_LERP(T, coords[0], Txm, Txp);
ELL_3V_LERP(g, coords[0], gxm, gxp);
if (yi!=sy-1) {
computeGradientLin(sctx->facenorm+3*(faceid+4*si), T, g,
Txm, gxm, Txp, gxp,
T, g, Typ, gyp,
Tzm, gzm, Tzp, gzp);
} else {
computeGradientLin(sctx->facenorm+3*(faceid+4*si), T, g,
Txm, gxm, Txp, gxp,
Tym, gym, T, g,
Tzm, gzm, Tzp, gzp);
}
break;
case 2:
/* bilinearly interpolate Txp/gxp first */
if (xi!=sx-1) {
ELL_3M_LERP(Tym, coords[1], sctx->t + 9*(0+2*six), sctx->t + 9*(1+2*six));
ELL_3V_LERP(gym, coords[1], sctx->grad + 3*(0+2*six),
sctx->grad + 3*(1+2*six));
ELL_3M_LERP(Typ, coords[1], sctx->t + 9*(0+2*sixy),
sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gyp, coords[1], sctx->grad + 3*(0+2*sixy),
sctx->grad + 3*(1+2*sixy));
ELL_3M_LERP(Txp, coords[0], Tym, Typ);
ELL_3V_LERP(gxp, coords[0], gym, gyp);
} else {
ELL_3M_LERP(Tym, coords[1], sctx->t + 9*(0+2*siX), sctx->t + 9*(1+2*siX));
ELL_3V_LERP(gym, coords[1], sctx->grad + 3*(0+2*siX),
sctx->grad + 3*(1+2*siX));
ELL_3M_LERP(Typ, coords[1], sctx->t + 9*(0+2*siXy),
sctx->t + 9*(1+2*siXy));
ELL_3V_LERP(gyp, coords[1], sctx->grad + 3*(0+2*siXy),
sctx->grad + 3*(1+2*siXy));
ELL_3M_LERP(Txm, coords[0], Tym, Typ);
ELL_3V_LERP(gxm, coords[0], gym, gyp);
}
/* now, compute remaining points */
ELL_3M_LERP(Tym, coords[1], sctx->t + 9*(0+2*si), sctx->t + 9*(1+2*si));
ELL_3V_LERP(gym, coords[1], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(1+2*si));
ELL_3M_LERP(Typ, coords[1], sctx->t + 9*(0+2*siy), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gyp, coords[1], sctx->grad + 3*(0+2*siy),
sctx->grad + 3*(1+2*siy));
ELL_3M_LERP(Tzm, coords[0], sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*siy));
ELL_3V_LERP(gzm, coords[0], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(0+2*siy));
ELL_3M_LERP(Tzp, coords[0], sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gzp, coords[0], sctx->grad + 3*(1+2*si),
sctx->grad + 3*(1+2*siy));
ELL_3M_LERP(T, coords[0], Tym, Typ);
ELL_3V_LERP(g, coords[0], gym, gyp);
if (xi!=sx-1) {
computeGradientLin(sctx->facenorm+3*(faceid+4*si), T, g,
T, g, Txp, gxp,
Tym, gym, Typ, gyp,
Tzm, gzm, Tzp, gzp);
} else {
computeGradientLin(sctx->facenorm+3*(faceid+4*si), T, g,
Txm, gxm, T, g,
Tym, gym, Typ, gyp,
Tzm, gzm, Tzp, gzp);
}
break;
case 3:
/* bilinearly interpolate Tzm/gzm first */
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(0+2*si), sctx->t + 9*(0+2*siy));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(0+2*si),
sctx->grad + 3*(0+2*siy));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(0+2*six), sctx->t + 9*(0+2*sixy));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(0+2*six),
sctx->grad + 3*(0+2*sixy));
ELL_3M_LERP(Tzm, coords[0], Txm, Txp);
ELL_3V_LERP(gzm, coords[0], gxm, gxp);
/* now, compute all required points on the top face */
ELL_3M_LERP(Txm, coords[1], sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*siy));
ELL_3V_LERP(gxm, coords[1], sctx->grad + 3*(1+2*si),
sctx->grad + 3*(1+2*siy));
ELL_3M_LERP(Txp, coords[1], sctx->t + 9*(1+2*six), sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gxp, coords[1], sctx->grad + 3*(1+2*six),
sctx->grad + 3*(1+2*sixy));
ELL_3M_LERP(Tym, coords[0], sctx->t + 9*(1+2*si), sctx->t + 9*(1+2*six));
ELL_3V_LERP(gym, coords[0], sctx->grad + 3*(1+2*si),
sctx->grad + 3*(1+2*six));
ELL_3M_LERP(Typ, coords[0], sctx->t + 9*(1+2*siy), sctx->t + 9*(1+2*sixy));
ELL_3V_LERP(gyp, coords[0], sctx->grad + 3*(1+2*siy),
sctx->grad + 3*(1+2*sixy));
ELL_3M_LERP(T, coords[0], Txm, Txp);
ELL_3V_LERP(g, coords[0], gxm, gxp);
computeGradientLin(sctx->facenorm+3*(faceid+4*si), T, g,
Txm, gxm, Txp, gxp,
Tym, gym, Typ, gyp,
Tzm, gzm, T, g);
break;
}
ELL_3V_COPY(res, sctx->facenorm+3*(faceid+4*si));
}
/* small helper routines: intersection tests */
/* check if a given 2D triangle is oriented clockwise (-1)
* or counter-clockwise (1).
* returns 0 if given points are collinear */
static int
checkTriOrientation (double *p1, double *p2, double *p3) {
double test = (((p2[0]-p1[0])*(p3[1]-p1[1])) - ((p3[0]-p1[0])*(p2[1]-p1[1])));
if (test > 0) return 1;
else if (test < 0) return -1;
else return 0;
}
/* check if two given 2D lines intersect */
static int
lineIntersectionTest (double *l1p1, double *l1p2, double *l2p1, double *l2p2) {
int or1 = checkTriOrientation(l1p1, l1p2, l2p1);
int or2 = checkTriOrientation(l1p1, l1p2, l2p2);
if (or1 != or2) {
or1 = checkTriOrientation(l2p1, l2p2, l1p1);
or2 = checkTriOrientation(l2p1, l2p2, l1p2);
if (or1 != or2)
return 1;
}
return 0;
}
/* check if two given 3D triangles intersect */
static int
triIntersectionTest (double *t1v1, double *t1v2, double *t1v3,
double *t2v1, double *t2v2, double *t2v3) {
double n1[3], n2[3], d1, d2;
double diff1[3], diff2[3];
double t2sd1, t2sd2, t2sd3;
ELL_3V_SUB(diff1, t1v2, t1v1);
ELL_3V_SUB(diff2, t1v3, t1v1);
ELL_3V_CROSS(n1,diff1,diff2);
d1=-ELL_3V_DOT(n1,t1v1);
/* compute scaled signed distances of t2 to plane of t1 */
t2sd1 = ELL_3V_DOT(n1, t2v1)+d1;
t2sd2 = ELL_3V_DOT(n1, t2v2)+d1;
t2sd3 = ELL_3V_DOT(n1, t2v3)+d1;
if (t2sd1==0 && t2sd2==0 && t2sd3==0) {
/* coplanar case: handle in 2D */
double t1v12d[2], t1v22d[2], t1v32d[2], t2v12d[2], t2v22d[2], t2v32d[2];
if (fabs(n1[0])>=fabs(n1[1]) && fabs(n1[0])>=fabs(n1[2])) {
t1v12d[0]=t1v1[1]; t1v12d[1]=t1v1[2];
t1v22d[0]=t1v2[1]; t1v22d[1]=t1v2[2];
t1v32d[0]=t1v3[1]; t1v32d[1]=t1v3[2];
t2v12d[0]=t2v1[1]; t2v12d[1]=t2v1[2];
t2v22d[0]=t2v2[1]; t2v22d[1]=t2v2[2];
t2v32d[0]=t2v3[1]; t2v32d[1]=t2v3[2];
} else if (fabs(n1[1])>=fabs(n1[0]) && fabs(n1[1])>=fabs(n1[2])) {
t1v12d[0]=t1v1[0]; t1v12d[1]=t1v1[2];
t1v22d[0]=t1v2[0]; t1v22d[1]=t1v2[2];
t1v32d[0]=t1v3[0]; t1v32d[1]=t1v3[2];
t2v12d[0]=t2v1[0]; t2v12d[1]=t2v1[2];
t2v22d[0]=t2v2[0]; t2v22d[1]=t2v2[2];
t2v32d[0]=t2v3[0]; t2v32d[1]=t2v3[2];
} else {
t1v12d[0]=t1v1[0]; t1v12d[1]=t1v1[1];
t1v22d[0]=t1v2[0]; t1v22d[1]=t1v2[1];
t1v32d[0]=t1v3[0]; t1v32d[1]=t1v3[1];
t2v12d[0]=t2v1[0]; t2v12d[1]=t2v1[1];
t2v22d[0]=t2v2[0]; t2v22d[1]=t2v2[1];
t2v32d[0]=t2v3[0]; t2v32d[1]=t2v3[1];
}
/* we may assume that none of the triangles is fully contained
* within the other. Thus, it suffices to do a lot of 2D line-line
* intersections */
if (lineIntersectionTest(t1v12d, t1v22d, t2v12d, t2v22d) ||
lineIntersectionTest(t1v22d, t1v32d, t2v12d, t2v22d) ||
lineIntersectionTest(t1v32d, t1v12d, t2v12d, t2v22d) ||
lineIntersectionTest(t1v12d, t1v22d, t2v22d, t2v32d) ||
lineIntersectionTest(t1v22d, t1v32d, t2v22d, t2v32d) ||
lineIntersectionTest(t1v32d, t1v12d, t2v22d, t2v32d) ||
lineIntersectionTest(t1v12d, t1v22d, t2v32d, t2v12d) ||
lineIntersectionTest(t1v22d, t1v32d, t2v32d, t2v12d) ||
lineIntersectionTest(t1v32d, t1v12d, t2v32d, t2v12d))
return 1;
return 0;
} else {
/* pointers to the vertices on the same side / opposite side of plane */
double *t2s11, *t2s12, *t2s2, t2s11sd, t2s12sd, t2s2sd;
double t1sd1, t1sd2, t1sd3;
double *t1s11, *t1s12, *t1s2, t1s11sd, t1s12sd, t1s2sd;
double t1p11, t1p12, t1p2, t2p11, t2p12, t2p2;
double D[3]; /* direction vector of line */
double t1t1, t1t2, t2t1, t2t2;
if (t2sd1*t2sd2>=0 && t2sd1*t2sd3<=0) {
t2s11=t2v1; t2s12=t2v2; t2s2=t2v3; t2s11sd=t2sd1;
t2s12sd=t2sd2; t2s2sd=t2sd3;
} else if (t2sd1*t2sd3>=0 && t2sd1*t2sd2<=0) {
t2s11=t2v1; t2s12=t2v3; t2s2=t2v2; t2s11sd=t2sd1;
t2s12sd=t2sd3; t2s2sd=t2sd2;
} else if (t2sd2*t2sd3>=0 && t2sd1*t2sd2<=0) {
t2s11=t2v2; t2s12=t2v3; t2s2=t2v1; t2s11sd=t2sd2;
t2s12sd=t2sd3; t2s2sd=t2sd1;
} else
return 0; /* all on the same side; no intersection */
/* same game for triangle 2 */
ELL_3V_SUB(diff1, t2v2, t2v1);
ELL_3V_SUB(diff2, t2v3, t2v1);
ELL_3V_CROSS(n2, diff1, diff2);
d2=-ELL_3V_DOT(n2,t2v1);
t1sd1 = ELL_3V_DOT(n2, t1v1)+d2;
t1sd2 = ELL_3V_DOT(n2, t1v2)+d2;
t1sd3 = ELL_3V_DOT(n2, t1v3)+d2;
if (t1sd1*t1sd2>=0 && t1sd1*t1sd3<=0) {
t1s11=t1v1; t1s12=t1v2; t1s2=t1v3; t1s11sd=t1sd1;
t1s12sd=t1sd2; t1s2sd=t1sd3;
} else if (t1sd1*t1sd3>=0 && t1sd1*t1sd2<=0) {
t1s11=t1v1; t1s12=t1v3; t1s2=t1v2; t1s11sd=t1sd1;
t1s12sd=t1sd3; t1s2sd=t1sd2;
} else if (t1sd2*t1sd3>=0 && t1sd1*t1sd2<=0) {
t1s11=t1v2; t1s12=t1v3; t1s2=t1v1; t1s11sd=t1sd2;
t1s12sd=t1sd3; t1s2sd=t1sd1;
} else
return 0; /* all on the same side; no intersection */
/* both planes intersect in a line; check if the intervals on that
* line intersect */
ELL_3V_CROSS(D,n1,n2);
/* we are only interested in component magnitudes */
D[0]=fabs(D[0]); D[1]=fabs(D[1]); D[2]=fabs(D[2]);
if (D[0]>=D[1] && D[0]>=D[2]) {
t1p11=t1s11[0]; t1p12=t1s12[0]; t1p2=t1s2[0];
t2p11=t2s11[0]; t2p12=t2s12[0]; t2p2=t2s2[0];
} else if (D[1]>=D[0] && D[1]>=D[2]) {
t1p11=t1s11[1]; t1p12=t1s12[1]; t1p2=t1s2[1];
t2p11=t2s11[1]; t2p12=t2s12[1]; t2p2=t2s2[1];
} else {
t1p11=t1s11[2]; t1p12=t1s12[2]; t1p2=t1s2[2];
t2p11=t2s11[2]; t2p12=t2s12[2]; t2p2=t2s2[2];
}
/* compute interval boundaries */
t1t1=t1p11+(t1p2-t1p11)*t1s11sd/(t1s11sd-t1s2sd);
t1t2=t1p12+(t1p2-t1p12)*t1s12sd/(t1s12sd-t1s2sd);
if (t1t1>t1t2) {
double help=t1t1;
t1t1=t1t2;
t1t2=help;
}
t2t1=t2p11+(t2p2-t2p11)*t2s11sd/(t2s11sd-t2s2sd);
t2t2=t2p12+(t2p2-t2p12)*t2s12sd/(t2s12sd-t2s2sd);
if (t2t1>t2t2) {
double help=t2t1;
t2t1=t2t2;
t2t2=help;
}
/* test for interval intersection */
if (t2t1>t1t2 || t1t1>t2t2) return 0;
return 1;
}
}
/* Score possible local topologies based on the agreement of
* connecting lines with normal directions. Lower scores are
* better. */
/* Connections between degenerate points on cell faces; if only four
* degenerate points are present, set p31 to NULL */
static double
evaluateDegConnection(double *p11, double *p12, double *p13, double *p14,
double *p21, double *p22, double *p23, double *p24,
double *p31, double *p32, double *p33, double *p34,
double *n12, double *n13, double *n22, double *n23,
double *n32, double *n33) {
double diff1[3], diff2[3], diff3[3], ret;
/* first, perform intersection testing */
if (triIntersectionTest(p11, p12, p13, p21, p22, p23) ||
triIntersectionTest(p13, p14, p11, p21, p22, p23) ||
triIntersectionTest(p11, p12, p13, p23, p24, p21) ||
triIntersectionTest(p13, p14, p11, p23, p24, p21))
return 1e20;
if (p31 != NULL) { /* three pairs - some more to do */
if (triIntersectionTest(p11, p12, p13, p31, p32, p33) ||
triIntersectionTest(p11, p12, p13, p33, p34, p31) ||
triIntersectionTest(p13, p14, p11, p31, p32, p33) ||
triIntersectionTest(p13, p14, p11, p33, p34, p31) ||
triIntersectionTest(p21, p22, p23, p31, p32, p33) ||
triIntersectionTest(p21, p22, p23, p33, p34, p31) ||
triIntersectionTest(p23, p24, p21, p31, p32, p33) ||
triIntersectionTest(p23, p24, p21, p33, p34, p31))
return 1e20;
}
ELL_3V_SUB(diff1,p13,p12);
ELL_3V_SUB(diff2,p23,p22);
ret=fabs(ELL_3V_DOT(diff1,n12))+fabs(ELL_3V_DOT(diff1,n13))+
fabs(ELL_3V_DOT(diff2,n22))+fabs(ELL_3V_DOT(diff2,n23));
if (p31 != NULL) {
ELL_3V_SUB(diff3,p33,p32);
ret+=fabs(ELL_3V_DOT(diff3,n32))+fabs(ELL_3V_DOT(diff3,n33));
}
return ret;
}
/* suggests a connectivity for a non-trivial combination of
* intersection points in the plane.
* pairs is output (permutation of idcs)
* bestval is input/output (best value so far, start with something big)
* ct is the number of points (currently assumed even)
* idcs is input (idcs that still need to be permuted)
* fixedct is input (number of idcs that are already fixed at this depth)
* coords is an array of 2D coordinates
* norms is an array of 2D vectors */
static void
findConnectivity(signed char *pairs, double *bestval, int ct, char *idcs,
int fixedct, double *coords, double *norms) {
int i,j;
if (fixedct==ct) {
double weight=0;
for (i=0; i<ct-1; i+=2) {
double diff[2];
ELL_2V_SUB(diff,coords+2*idcs[i],coords+2*idcs[i+1]);
weight+=fabs(ELL_2V_DOT(diff,norms+2*idcs[i]))+
fabs(ELL_2V_DOT(diff,norms+2*idcs[i+1]));
}
if (weight<*bestval) {
*bestval=weight;
memcpy(pairs,idcs,sizeof(char)*ct);
}
return;
}
/* else: we need a recursion */
for (i=fixedct+1; i<ct; i++) {
int intersect=0;
char *idxnew;
if (NULL == (idxnew = (char*) malloc (sizeof(char)*ct)))
return;
memcpy(idxnew,idcs,sizeof(char)*ct);
/* try any of the remaining indices as a pair */
idxnew[fixedct+1]=idcs[i];
idxnew[i]=idcs[fixedct+1];
/* check if the resulting line causes an intersection */
for (j=0;j<fixedct;j+=2) {
if (lineIntersectionTest(coords+2*idxnew[fixedct],
coords+2*idxnew[fixedct+1],
coords+2*idxnew[j],coords+2*idxnew[j+1])) {
intersect=1;
break;
}
}
if (!intersect) {
findConnectivity(pairs, bestval, ct, idxnew, fixedct+2, coords, norms);
}
free(idxnew);
}
}
#define _SEEK_TREATED_REQUEST 0x01 /* this voxel has to be treated */
#define _SEEK_TREATED_EDGE0 0x02 /* unique edge 0 has been treated */
#define _SEEK_TREATED_EDGE1 0x04 /* unique edge 1 has been treated */
#define _SEEK_TREATED_EDGE2 0x08 /* unique edge 2 has been treated */
#define _SEEK_TREATED_EDGE3 0x10 /* unique edge 3 has been treated */
#define _SEEK_TREATED_EDGE4 0x20 /* unique edge 4 has been treated */
#define _SEEK_TREATED_FACE3 0x40 /* unique face 3 has been treated */
/* find deg. points, normals, and connectivity on a given (unique) face
* now refines the search if it couldn't find a degenerate point */
static void
connectFace(seekContext *sctx, baggage *bag,
unsigned int xi, unsigned int yi, unsigned char faceid) {
int edgeid[4][4]={{0, 2, 3, 1}, /* which edges belong to which unique face? */
{0, 5, 8, 4},
{1, 6, 9, 4},
{8,10,11, 9}};
unsigned int sx = AIR_CAST(unsigned int, sctx->sx);
unsigned int si = xi + sx*yi;
unsigned int six = xi + 1 + sx*yi;
unsigned int siy = xi + sx*(yi+1);
unsigned int sixy = xi + 1 + sx*(yi+1);
char inter[12]; /* indices of intersections */
int pass; /* allow multiple refined passes */
int i;
/* voxel in which treated information is stored for local edge i */
/* which vertices form which unique face? */
int verti[4][4];
int voxel[4][4];
/* mask for treated information in the above voxel */
char mask[4][4]={{_SEEK_TREATED_EDGE0, _SEEK_TREATED_EDGE1,
_SEEK_TREATED_EDGE0, _SEEK_TREATED_EDGE1},
{_SEEK_TREATED_EDGE0, _SEEK_TREATED_EDGE2,
_SEEK_TREATED_EDGE3, _SEEK_TREATED_EDGE2},
{_SEEK_TREATED_EDGE1, _SEEK_TREATED_EDGE2,
_SEEK_TREATED_EDGE4, _SEEK_TREATED_EDGE2},
{_SEEK_TREATED_EDGE3, _SEEK_TREATED_EDGE4,
_SEEK_TREATED_EDGE3, _SEEK_TREATED_EDGE4}};
/* start- and endpoints of the edges */
int verts[4][4], verte[4][4];
char treat[4]={0,0,0,0};
double dpthresh[3]={0.7,0.8,0.9};
/* candidates for degenerate points */
double candidates[18]={0.5,0.5, 0.25,0.25, 0.25,0.75,
0.75,0.25, 0.75,0.75, 0.5,0.25,
0.25,0.5, 0.75,0.5, 0.6,0.75};
int cand_idx[4]={0, 1, 5, 9};
int interct;
/* apparently, some C compilers cannot make these initializations in-place */
ELL_4V_SET(verti[0], 0+2*si, 0+2*six, 0+2*siy, 0+2*sixy);
ELL_4V_SET(verti[1], 0+2*si, 0+2*six, 1+2*si, 1+2*six);
ELL_4V_SET(verti[2], 0+2*si, 0+2*siy, 1+2*si, 1+2*siy);
ELL_4V_SET(verti[3], 1+2*si, 1+2*six, 1+2*siy, 1+2*sixy);
ELL_4V_SET(voxel[0], si, six, siy, si);
ELL_4V_SET(voxel[1], si, six, si, si);
ELL_4V_SET(voxel[2], si, siy, si, si);
ELL_4V_SET(voxel[3], si, six, siy, si);
ELL_4V_SET(verts[0], 0+2*si, 0+2*six, 0+2*siy, 0+2*si);
ELL_4V_SET(verts[1], 0+2*si, 0+2*six, 1+2*si, 0+2*si);
ELL_4V_SET(verts[2], 0+2*si, 0+2*siy, 1+2*si, 0+2*si);
ELL_4V_SET(verts[3], 1+2*si, 1+2*six, 1+2*siy, 1+2*si);
ELL_4V_SET(verte[0], 0+2*six, 0+2*sixy, 0+2*sixy, 0+2*siy);
ELL_4V_SET(verte[1], 0+2*six, 1+2*six, 1+2*six, 1+2*si);
ELL_4V_SET(verte[2], 0+2*siy, 1+2*siy, 1+2*siy, 1+2*si);
ELL_4V_SET(verte[3], 1+2*six, 1+2*sixy, 1+2*sixy, 1+2*siy);
/* find out which edges have not yet been treated */
for (i=0; i<4; i++) {
if (!(sctx->treated[voxel[faceid][i]]&mask[faceid][i])) {
treat[i]=1; /* we need to treat this */
sctx->treated[voxel[faceid][i]] |= mask[faceid][i];
}
}
for (pass=0; pass<3; pass++) {
/* first, find intersections for edges that need treatment */
int j;
for (j=0; j<4; j++) {
double interpos[8];
int interct;
if (!treat[j]) continue;
interct=findFeatureIntersection(interpos,
sctx->t + 9*verts[faceid][j],
sctx->hess + 9*verts[faceid][j],
sctx->grad + 3*verts[faceid][j],
sctx->t + 9*verte[faceid][j],
sctx->hess + 9*verte[faceid][j],
sctx->grad + 3*verte[faceid][j],
0.0, 1.0, bag->esIdx==2,
sctx->evalDiffThresh,
dpthresh[pass]);
if (interct>3) interct=3;
for (i=0; i<interct; i++) {
double x=0, y=0, z=0; unsigned int xb=0, yb=0, idb=0;
sctx->edgealpha[3*(bag->evti[edgeid[faceid][j]]+5*si)+i] = interpos[i];
switch (edgeid[faceid][j]) {
case 0: x=xi+interpos[i]; y=yi; z=bag->zi;
xb=xi; yb=yi; idb=0; break;
case 1: x=xi; y=yi+interpos[i]; z=bag->zi;
xb=xi; yb=yi; idb=1; break;
case 2: x=xi+1; y=yi+interpos[i]; z=bag->zi;
xb=xi+1; yb=yi; idb=1; break;
case 3: x=xi+interpos[i]; y=yi+1; z=bag->zi;
xb=xi; yb=yi+1; idb=0; break;
case 4: x=xi; y=yi; z=bag->zi+interpos[i];
xb=xi; yb=yi; idb=2; break;
case 5: x=xi+1; y=yi; z=bag->zi+interpos[i];
xb=xi+1; yb=yi; idb=2; break;
case 6: x=xi; y=yi+1; z=bag->zi+interpos[i];
xb=xi; yb=yi+1; idb=2; break;
case 7: x=xi+1; y=yi+1; z=bag->zi+interpos[i];
xb=xi+1; yb=yi+1; idb=2; break;
case 8: x=xi+interpos[i]; y=yi; z=bag->zi+1;
xb=xi; yb=yi; idb=3; break;
case 9: x=xi; y=yi+interpos[i]; z=bag->zi+1;
xb=xi; yb=yi; idb=4; break;
case 10: x=xi+1; y=yi+interpos[i]; z=bag->zi+1;
xb=xi+1; yb=yi; idb=4; break;
case 11: x=xi+interpos[i]; y=yi+1; z=bag->zi+1;
xb=xi; yb=yi+1; idb=3; break;
}
ELL_3V_SET(sctx->edgeicoord+9*(bag->evti[edgeid[faceid][j]]+5*si)+3*i,
x, y, z);
computeEdgeGradient(sctx, bag, sctx->edgenorm+
9*(bag->evti[edgeid[faceid][j]]+5*si)+3*i,
xb, yb, idb, interpos[i]);
}
}
interct=0; /* number of feature intersections */
for (i=0; i<3; i++) {
if (sctx->edgealpha[3*(bag->evti[edgeid[faceid][0]]+5*si)+i]>=0)
inter[interct++]=i; /* numbering is local w.r.t. face */
if (sctx->edgealpha[3*(bag->evti[edgeid[faceid][1]]+5*si)+i]>=0)
inter[interct++]=3+i;
if (sctx->edgealpha[3*(bag->evti[edgeid[faceid][2]]+5*si)+i]>=0)
inter[interct++]=6+i;
if (sctx->edgealpha[3*(bag->evti[edgeid[faceid][3]]+5*si)+i]>=0)
inter[interct++]=9+i;
}
if (interct%2==1) { /* we need to look for a degeneracy */
int k;
for (k=cand_idx[pass]; k<cand_idx[pass+1]; k++) {
ELL_2V_SET(sctx->facecoord+2*(faceid+4*si),
candidates[2*k], candidates[2*k+1]);
if (!seekDescendToDeg(sctx->facecoord+2*(faceid+4*si),
sctx->hess + 9*verti[faceid][0],
sctx->hess + 9*verti[faceid][1],
sctx->hess + 9*verti[faceid][2],
sctx->hess + 9*verti[faceid][3],
30, 1e-4, (bag->esIdx==2)?'l':'p')) {
inter[interct++]=12; /* 12 means "deg. point on this face */
break;
}
}
if ((pass==2) && (inter[interct-1]!=12)) {
/* nothing helped, so insert a dummy vertex */
ELL_2V_SET(sctx->facecoord+2*(faceid+4*si), 0.5, 0.5);
inter[interct++]=12;
}
if (inter[interct-1]==12) {
computeFaceGradient(sctx, sctx->facenorm+3*(faceid+4*si),
xi, yi, faceid, sctx->facecoord+2*(faceid+4*si));
switch (faceid) {
case 0: ELL_3V_SET(sctx->faceicoord+3*(faceid+4*si),
xi+sctx->facecoord[2*(faceid+4*si)],
yi+sctx->facecoord[2*(faceid+4*si)+1], bag->zi);
break;
case 1: ELL_3V_SET(sctx->faceicoord+3*(faceid+4*si),
xi+sctx->facecoord[2*(faceid+4*si)], yi,
bag->zi+sctx->facecoord[2*(faceid+4*si)+1]);
break;
case 2: ELL_3V_SET(sctx->faceicoord+3*(faceid+4*si), xi,
yi+sctx->facecoord[2*(faceid+4*si)],
bag->zi+sctx->facecoord[2*(faceid+4*si)+1]);
break;
case 3: ELL_3V_SET(sctx->faceicoord+3*(faceid+4*si),
xi+sctx->facecoord[2*(faceid+4*si)],
yi+sctx->facecoord[2*(faceid+4*si)+1], bag->zi+1);
break;
}
}
}
if (interct%2==0) { /* we can break out */
break;
}
}
if (interct<=1) { /* there is no connectivity on this face */
ELL_4V_SET(sctx->pairs+12*(faceid+4*si),-1,-1,-1,-1);
} else if (interct==2) { /* connectivity is straightforward */
ELL_4V_SET(sctx->pairs+12*(faceid+4*si),inter[0],inter[1],-1,-1);
} else { /* we need gradients and coordinates to make a decision */
double interc[24]; /* 2D coordinates of intersection points */
double intern[24]; /* 2D normals at intersection points */
/* used to find the best pairing without self-intersection */
double bestscore=1e20;
char idcs[12]; /* consider if we need to restrict this */
for (i=0; i<interct; i++) {
if (inter[i]<12) { /* edge feature */
int resolved=edgeid[faceid][inter[i]/3];
int offset=inter[i]%3;
switch (faceid) {
case 0: case 3:
ELL_2V_SET(interc+2*i,
sctx->edgeicoord[9*(bag->evti[resolved]+5*si)+3*offset],
sctx->edgeicoord[9*(bag->evti[resolved]+5*si)+3*offset+1]);
ELL_2V_SET(intern+2*i,
sctx->edgenorm[9*(bag->evti[resolved]+5*si)+3*offset],
sctx->edgenorm[9*(bag->evti[resolved]+5*si)+3*offset+1]);
break;
case 1:
ELL_2V_SET(interc+2*i,
sctx->edgeicoord[9*(bag->evti[resolved]+5*si)+3*offset],
sctx->edgeicoord[9*(bag->evti[resolved]+5*si)+3*offset+2]);
ELL_2V_SET(intern+2*i,
sctx->edgenorm[9*(bag->evti[resolved]+5*si)+3*offset],
sctx->edgenorm[9*(bag->evti[resolved]+5*si)+3*offset+2]);
break;
case 2:
ELL_2V_SET(interc+2*i,
sctx->edgeicoord[9*(bag->evti[resolved]+5*si)+3*offset+1],
sctx->edgeicoord[9*(bag->evti[resolved]+5*si)+3*offset+2]);
ELL_2V_SET(intern+2*i,
sctx->edgenorm[9*(bag->evti[resolved]+5*si)+3*offset+1],
sctx->edgenorm[9*(bag->evti[resolved]+5*si)+3*offset+2]);
break;
}
} else { /* face feature */
switch (faceid) {
case 0: case 3:
ELL_2V_SET(interc+2*i, sctx->faceicoord[3*(faceid+4*si)],
sctx->faceicoord[3*(faceid+4*si)+1]);
ELL_2V_SET(intern+2*i, sctx->facenorm[3*(faceid+4*si)],
sctx->facenorm[3*(faceid+4*si)+1]);
break;
case 1:
ELL_2V_SET(interc+2*i, sctx->faceicoord[3*(faceid+4*si)],
sctx->faceicoord[3*(faceid+4*si)+2]);
ELL_2V_SET(intern+2*i, sctx->facenorm[3*(faceid+4*si)],
sctx->facenorm[3*(faceid+4*si)+2]);
break;
case 2:
ELL_2V_SET(interc+2*i, sctx->faceicoord[3*(faceid+4*si)+1],
sctx->faceicoord[3*(faceid+4*si)+2]);
ELL_2V_SET(intern+2*i, sctx->facenorm[3*(faceid+4*si)+1],
sctx->facenorm[3*(faceid+4*si)+2]);
break;
}
}
}
for (i=0; i<interct; i++) {
sctx->pairs[12*(faceid+4*si)+i]=i;
idcs[i]=i;
}
findConnectivity(sctx->pairs+12*(faceid+4*si), &bestscore, interct,
idcs, 0, interc, intern);
for (i=0; i<interct; i++)
sctx->pairs[12*(faceid+4*si)+i]=inter[sctx->pairs[12*(faceid+4*si)+i]];
for (i=interct; i<12; i++)
sctx->pairs[12*(faceid+4*si)+i]=-1;
}
}
static void
intersectionShuffleProbe(seekContext *sctx, baggage *bag) {
unsigned int xi, yi, sx, sy, si, six, siy, sixy;
int i;
sx = AIR_CAST(unsigned int, sctx->sx);
sy = AIR_CAST(unsigned int, sctx->sy);
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
si = xi + sx*yi;
six = xi + 1 + sx*yi;
siy = xi + sx*(yi+1);
sixy = xi + 1 + sx*(yi+1);
/* take care of facevidx array */
if (!bag->zi) { /* initialize, else copy over */
sctx->facevidx[0 + 4*si] = -1;
} else {
sctx->facevidx[0 + 4*si] = sctx->facevidx[3 + 4*si];
}
sctx->facevidx[1 + 4*si] = sctx->facevidx[2 + 4*si] =
sctx->facevidx[3 + 4*si] = -1;
/* copy or reset data on the 5 unique edges */
if (sctx->treated[si]&_SEEK_TREATED_EDGE3) {
/* has been treated, just copy results */
ELL_3V_COPY(sctx->edgealpha+3*(0+5*si), sctx->edgealpha+3*(3+5*si));
ELL_3M_COPY(sctx->edgenorm+9*(0+5*si), sctx->edgenorm+9*(3+5*si));
ELL_3M_COPY(sctx->edgeicoord+9*(0+5*si), sctx->edgeicoord+9*(3+5*si));
sctx->treated[si]|=_SEEK_TREATED_EDGE0;
} else if (xi!=sx-1) {
ELL_3V_SET(sctx->edgealpha+3*(0+5*si),-1,-1,-1);
sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE0;
}
if (sctx->treated[si]&_SEEK_TREATED_EDGE4) {
/* has been treated, just copy results */
ELL_3V_COPY(sctx->edgealpha+3*(1+5*si), sctx->edgealpha+3*(4+5*si));
ELL_3M_COPY(sctx->edgenorm+9*(1+5*si), sctx->edgenorm+9*(4+5*si));
ELL_3M_COPY(sctx->edgeicoord+9*(1+5*si), sctx->edgeicoord+9*(4+5*si));
sctx->treated[si]|=_SEEK_TREATED_EDGE1;
} else if (yi!=sy-1) {
ELL_3V_SET(sctx->edgealpha+3*(1+5*si),-1,-1,-1);
sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE1;
}
/* edges within and at top of the slab are new */
ELL_3V_SET(sctx->edgealpha+3*(2+5*si),-1,-1,-1);
sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE2;
ELL_3V_SET(sctx->edgealpha+3*(3+5*si),-1,-1,-1);
sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE3;
ELL_3V_SET(sctx->edgealpha+3*(4+5*si),-1,-1,-1);
sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE4;
}
}
/* find missing deg. points, edge intersections, normals, and
* connectivity on the four unique faces
* this is done in a separate pass to make sure that all edge information
* has been updated */
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
si = xi + sx*yi;
if (sctx->treated[si]&_SEEK_TREATED_FACE3) {
/* we can copy previous results */
ELL_2V_COPY(sctx->facecoord+2*(0+4*si), sctx->facecoord+2*(3+4*si));
ELL_3V_COPY(sctx->faceicoord+3*(0+4*si), sctx->faceicoord+3*(3+4*si));
ELL_3V_COPY(sctx->facenorm+3*(0+4*si), sctx->facenorm+3*(3+4*si));
for (i=0; i<3; i++)
ELL_4V_COPY(sctx->pairs+12*(0+4*si)+4*i, sctx->pairs+12*(3+4*si)+4*i);
} else if (xi!=sx-1 && yi!=sy-1) {
if (sctx->treated[si]&_SEEK_TREATED_REQUEST)
connectFace(sctx, bag, xi, yi, 0);
else
ELL_4V_SET(sctx->pairs+12*(0+4*si),-1,-1,-1,-1);
}
if (xi!=sx-1) {
if (sctx->treated[si]&_SEEK_TREATED_REQUEST ||
(yi!=0 && sctx->treated[xi+sx*(yi-1)]&_SEEK_TREATED_REQUEST))
connectFace(sctx, bag, xi, yi, 1);
else ELL_4V_SET(sctx->pairs+12*(1+4*si),-1,-1,-1,-1);
}
if (yi!=sy-1) {
if (sctx->treated[si]&_SEEK_TREATED_REQUEST ||
(xi!=0 && sctx->treated[xi-1+sx*yi]&_SEEK_TREATED_REQUEST))
connectFace(sctx, bag, xi, yi, 2);
else ELL_4V_SET(sctx->pairs+12*(2+4*si),-1,-1,-1,-1);
if (xi!=sx-1) {
if (sctx->treated[si]&_SEEK_TREATED_REQUEST) {
connectFace(sctx, bag, xi, yi, 3);
sctx->treated[si]|=_SEEK_TREATED_FACE3;
} else {
ELL_4V_SET(sctx->pairs+12*(3+4*si),-1,-1,-1,-1);
sctx->treated[si]&=0xFF^_SEEK_TREATED_FACE3;
}
}
}
}
}
}
/* special triangulation routine for use with T-based extraction */
int
_seekTriangulateT(seekContext *sctx, baggage *bag, limnPolyData *lpld) {
unsigned xi, yi, sx, sy, si, i;
/* map edge indices w.r.t. faces (as used in sctx->pairs) back to
* edge indices w.r.t. voxel */
char edges[6][5]={{0, 2, 3, 1,12},
{0, 5, 8, 4,13},
{2, 7,10, 5,14},
{3, 7,11, 6,15},
{1, 6, 9, 4,16},
{8,10,11, 9,17}};
sx = AIR_CAST(unsigned int, sctx->sx);
sy = AIR_CAST(unsigned int, sctx->sy);
for (yi=0; yi<sy-1; yi++) {
for (xi=0; xi<sx-1; xi++) {
int fvti[6]; /* indices into unique face array */
char connections[84];/* (12 edges * 3 possible intersections+6 faces)*2 */
char degeneracies[6];
int degct=0;
unsigned int face;
if (sctx->strengthUse && sctx->stng[0+2*(xi+sx*yi)] < sctx->strength &&
sctx->stng[1+2*(xi+sx*yi)] < sctx->strength &&
sctx->stng[0+2*(xi+1+sx*yi)] < sctx->strength &&
sctx->stng[1+2*(xi+1+sx*yi)] < sctx->strength &&
sctx->stng[0+2*(xi+sx*(yi+1))] < sctx->strength &&
sctx->stng[1+2*(xi+sx*(yi+1))] < sctx->strength &&
sctx->stng[0+2*(xi+1+sx*(yi+1))] < sctx->strength &&
sctx->stng[1+2*(xi+1+sx*(yi+1))] < sctx->strength)
continue;/* all vertices below strength limit, do not create geometry */
si = xi + sx*yi;
ELL_3V_SET(fvti, 0 + 4*si, 1 + 4*si, 2 + 4*(xi+1 + sx*yi));
ELL_3V_SET(fvti+3, 1 + 4*(xi + sx*(yi+1)), 2 + 4*si, 3 + 4*si);
/* collect all intersection + connectivity info for this voxel */
memset(connections,-1,sizeof(connections));
for (face=0; face<6; face++) {
int i;
for (i=0; i<6; i++) {
int idx1, offset1, idx2, offset2, idxmap1, idxmap2;
if (sctx->pairs[12*fvti[face]+2*i]==-1) break;
idx1=edges[face][sctx->pairs[12*fvti[face]+2*i]/3];
offset1=sctx->pairs[12*fvti[face]+2*i]%3;
idx2=edges[face][sctx->pairs[12*fvti[face]+2*i+1]/3];
offset2=sctx->pairs[12*fvti[face]+2*i+1]%3;
idxmap1=3*idx1+offset1;
idxmap2=3*idx2+offset2;
if (idx1>11) {
idxmap1=idx1+24; /* +36-12 */
degeneracies[degct++] = idxmap1;
}
if (idx2>11) {
idxmap2=idx2+24;
degeneracies[degct++] = idxmap2;
}
if (connections[2*idxmap1]==-1)
connections[2*idxmap1]=idxmap2;
else
connections[2*idxmap1+1]=idxmap2;
if (connections[2*idxmap2]==-1)
connections[2*idxmap2]=idxmap1;
else
connections[2*idxmap2+1]=idxmap1;
}
}
/* connect the degenerate points */
if (degct==2) {
connections[2*degeneracies[0]+1]=degeneracies[1];
connections[2*degeneracies[1]+1]=degeneracies[0];
} else if (degct==4) {
int bestchoice=0;
int eidcs[4], fidcs[4];
int k;
double bestscore, score;
for (k=0; k<4; ++k) {
eidcs[k]=3*(bag->evti[connections[2*degeneracies[k]]/3]+5*si)+
connections[2*degeneracies[k]]%3;
fidcs[k]=fvti[degeneracies[k]-36];
}
bestscore=evaluateDegConnection(sctx->edgeicoord+3*eidcs[0],
sctx->faceicoord+3*fidcs[0],
sctx->faceicoord+3*fidcs[1],
sctx->edgeicoord+3*eidcs[1],
sctx->edgeicoord+3*eidcs[2],
sctx->faceicoord+3*fidcs[2],
sctx->faceicoord+3*fidcs[3],
sctx->edgeicoord+3*eidcs[3],
NULL, NULL, NULL, NULL,
sctx->facenorm+3*fidcs[0],
sctx->facenorm+3*fidcs[1],
sctx->facenorm+3*fidcs[2],
sctx->facenorm+3*fidcs[3],
NULL, NULL);
score=evaluateDegConnection(sctx->edgeicoord+3*eidcs[0],
sctx->faceicoord+3*fidcs[0],
sctx->faceicoord+3*fidcs[2],
sctx->edgeicoord+3*eidcs[2],
sctx->edgeicoord+3*eidcs[1],
sctx->faceicoord+3*fidcs[1],
sctx->faceicoord+3*fidcs[3],
sctx->edgeicoord+3*eidcs[3],
NULL, NULL, NULL, NULL,
sctx->facenorm+3*fidcs[0],
sctx->facenorm+3*fidcs[2],
sctx->facenorm+3*fidcs[1],
sctx->facenorm+3*fidcs[3],
NULL, NULL);
if (score<bestscore) {
bestscore=score;
bestchoice=1;
}
score=evaluateDegConnection(sctx->edgeicoord+3*eidcs[0],
sctx->faceicoord+3*fidcs[0],
sctx->faceicoord+3*fidcs[3],
sctx->edgeicoord+3*eidcs[3],
sctx->edgeicoord+3*eidcs[1],
sctx->faceicoord+3*fidcs[1],
sctx->faceicoord+3*fidcs[2],
sctx->edgeicoord+3*eidcs[2],
NULL, NULL, NULL, NULL,
sctx->facenorm+3*fidcs[0],
sctx->facenorm+3*fidcs[3],
sctx->facenorm+3*fidcs[1],
sctx->facenorm+3*fidcs[2],
NULL, NULL);
if (score<bestscore) {
bestscore=score;
bestchoice=2;
}
switch (bestchoice) {
case 0: connections[2*degeneracies[0]+1]=degeneracies[1];
connections[2*degeneracies[1]+1]=degeneracies[0];
connections[2*degeneracies[2]+1]=degeneracies[3];
connections[2*degeneracies[3]+1]=degeneracies[2];
break;
case 1: connections[2*degeneracies[0]+1]=degeneracies[2];
connections[2*degeneracies[2]+1]=degeneracies[0];
connections[2*degeneracies[1]+1]=degeneracies[3];
connections[2*degeneracies[3]+1]=degeneracies[1];
break;
case 2: connections[2*degeneracies[0]+1]=degeneracies[3];
connections[2*degeneracies[3]+1]=degeneracies[0];
connections[2*degeneracies[1]+1]=degeneracies[2];
connections[2*degeneracies[2]+1]=degeneracies[1];
break;
}
} else if (degct==6) {
int bestchoice=0;
int eidcs[6], fidcs[6];
int k;
double bestscore;
int pairings[15][6]={{0,1,2,3,4,5},{0,1,2,4,3,5},{0,1,2,5,3,4},
{0,2,1,3,4,5},{0,2,1,4,3,5},{0,2,1,5,3,4},
{0,3,1,2,4,5},{0,3,1,4,2,5},{0,3,1,5,2,4},
{0,4,1,2,3,5},{0,4,1,3,2,5},{0,4,1,5,2,3},
{0,5,1,2,3,4},{0,5,1,3,2,4},{0,5,1,4,2,3}};
for (k=0; k<6; ++k) {
eidcs[k]=3*(bag->evti[connections[2*degeneracies[k]]/3]+5*si)+
connections[2*degeneracies[k]]%3;
fidcs[k]=fvti[degeneracies[k]-36];
}
bestscore=evaluateDegConnection(sctx->edgeicoord+3*eidcs[0],
sctx->faceicoord+3*fidcs[0],
sctx->faceicoord+3*fidcs[1],
sctx->edgeicoord+3*eidcs[1],
sctx->edgeicoord+3*eidcs[2],
sctx->faceicoord+3*fidcs[2],
sctx->faceicoord+3*fidcs[3],
sctx->edgeicoord+3*eidcs[3],
sctx->edgeicoord+3*eidcs[4],
sctx->faceicoord+3*fidcs[4],
sctx->faceicoord+3*fidcs[5],
sctx->edgeicoord+3*eidcs[5],
sctx->facenorm+3*fidcs[0],
sctx->facenorm+3*fidcs[1],
sctx->facenorm+3*fidcs[2],
sctx->facenorm+3*fidcs[3],
sctx->facenorm+3*fidcs[4],
sctx->facenorm+3*fidcs[5]);
for (k=1; k<15; ++k) {
double score=evaluateDegConnection
(sctx->edgeicoord+3*eidcs[pairings[k][0]],
sctx->faceicoord+3*fidcs[pairings[k][0]],
sctx->faceicoord+3*fidcs[pairings[k][1]],
sctx->edgeicoord+3*eidcs[pairings[k][1]],
sctx->edgeicoord+3*eidcs[pairings[k][2]],
sctx->faceicoord+3*fidcs[pairings[k][2]],
sctx->faceicoord+3*fidcs[pairings[k][3]],
sctx->edgeicoord+3*eidcs[pairings[k][3]],
sctx->edgeicoord+3*eidcs[pairings[k][4]],
sctx->faceicoord+3*fidcs[pairings[k][4]],
sctx->faceicoord+3*fidcs[pairings[k][5]],
sctx->edgeicoord+3*eidcs[pairings[k][5]],
sctx->facenorm+3*fidcs[pairings[k][0]],
sctx->facenorm+3*fidcs[pairings[k][1]],
sctx->facenorm+3*fidcs[pairings[k][2]],
sctx->facenorm+3*fidcs[pairings[k][3]],
sctx->facenorm+3*fidcs[pairings[k][4]],
sctx->facenorm+3*fidcs[pairings[k][5]]);
if (score<bestscore) {
bestscore=score; bestchoice=k;
}
}
connections[2*degeneracies[pairings[bestchoice][0]]+1]=
degeneracies[pairings[bestchoice][1]];
connections[2*degeneracies[pairings[bestchoice][1]]+1]=
degeneracies[pairings[bestchoice][0]];
connections[2*degeneracies[pairings[bestchoice][2]]+1]=
degeneracies[pairings[bestchoice][3]];
connections[2*degeneracies[pairings[bestchoice][3]]+1]=
degeneracies[pairings[bestchoice][2]];
connections[2*degeneracies[pairings[bestchoice][4]]+1]=
degeneracies[pairings[bestchoice][5]];
connections[2*degeneracies[pairings[bestchoice][5]]+1]=
degeneracies[pairings[bestchoice][4]];
}
/* sufficient to run to 36: each polygon will contain at least
* one edge vertex */
for (i=0; i<36; i++) {
if (connections[2*i]!=-1) {
/* extract polygon from connections array */
signed char polygon[42];
unsigned char polyct=0;
char this=i;
char next=connections[2*i];
polygon[polyct++]=i;
connections[2*i]=-1;
while (next!=-1) {
char helpnext;
polygon[polyct++]=next;
if (connections[2*next]==this) {
helpnext=connections[2*next+1];
} else {
helpnext=connections[2*next];
}
connections[2*next]=connections[2*next+1]=-1;
this = next; next = helpnext;
if (next==polygon[0])
break; /* polygon is closed */
}
if (next!=-1) { /* else: discard unclosed polygon */
/* make sure all required vertices are there */
int j;
for (j=0; j<polyct; ++j) {
double tvertA[4], tvertB[4];
if (polygon[j]<36) { /* we may need to insert an edge vertex */
int eidx=3*(bag->evti[polygon[j]/3] + 5*si)+polygon[j]%3;
if (-1 == sctx->vidx[eidx]) {
int ovi;
ELL_3V_COPY(tvertA, sctx->edgeicoord+3*eidx);
tvertA[3]=1.0;
/* tvertB in input index space */
ELL_4MV_MUL(tvertB, sctx->txfIdx, tvertA);
/* tvertA in world space */
ELL_4MV_MUL(tvertA, sctx->shape->ItoW, tvertB);
ELL_4V_HOMOG(tvertA, tvertA);
ovi = sctx->vidx[eidx] =
airArrayLenIncr(bag->xyzwArr, 1);
ELL_4V_SET_TT(lpld->xyzw + 4*ovi, float,
tvertA[0], tvertA[1], tvertA[2], 1.0);
if (sctx->normalsFind) {
double len=ELL_3V_LEN(sctx->edgenorm+3*eidx);
airArrayLenIncr(bag->normArr, 1);
ELL_3V_SCALE_TT(lpld->norm + 3*ovi, float, 1.0/len,
sctx->edgenorm+3*eidx);
}
sctx->vertNum++;
}
} else { /* we may need to insert a face vertex */
int fidx=fvti[polygon[j]-36];
if (-1 == sctx->facevidx[fidx]) {
int ovi;
ELL_3V_COPY(tvertA, sctx->faceicoord+3*fidx);
tvertA[3]=1.0;
/* tvertB in input index space */
ELL_4MV_MUL(tvertB, sctx->txfIdx, tvertA);
/* tvertA in world space */
ELL_4MV_MUL(tvertA, sctx->shape->ItoW, tvertB);
ELL_4V_HOMOG(tvertA, tvertA);
ovi = sctx->facevidx[fidx] =
airArrayLenIncr(bag->xyzwArr, 1);
ELL_4V_SET_TT(lpld->xyzw + 4*ovi, float,
tvertA[0], tvertA[1], tvertA[2], 1.0);
if (sctx->normalsFind) {
double len=ELL_3V_LEN(sctx->facenorm+3*fidx);
airArrayLenIncr(bag->normArr, 1);
ELL_3V_SCALE_TT(lpld->norm + 3*ovi, float, 1.0/len,
sctx->facenorm+3*fidx);
}
sctx->vertNum++;
}
}
}
if (polyct>4) { /* we need to insert a helper vertex */
double tvertA[4], tvertB[4], tvertAsum[4]={0,0,0,0},
normsum[3]={0,0,0};
int ovi;
unsigned int vii[3];
for (j=0; j<polyct; j++) {
if (polygon[j]<36) {
int eidx=3*(bag->evti[polygon[j]/3] + 5*si)+polygon[j]%3;
ELL_3V_COPY(tvertA, sctx->edgeicoord+3*eidx);
tvertA[3]=1.0;
ELL_4V_INCR(tvertAsum,tvertA);
if (ELL_3V_DOT(normsum,sctx->edgenorm+3*eidx)<0)
ELL_3V_SUB(normsum,normsum,sctx->edgenorm+3*eidx);
else
ELL_3V_INCR(normsum,sctx->edgenorm+3*eidx);
} else {
int fidx=fvti[polygon[j]-36];
ELL_3V_COPY(tvertA, sctx->faceicoord+3*fidx);
tvertA[3]=1.0;
ELL_4V_INCR(tvertAsum,tvertA);
if (ELL_3V_DOT(normsum,sctx->facenorm+3*fidx)<0)
ELL_3V_SUB(normsum,normsum,sctx->facenorm+3*fidx);
else
ELL_3V_INCR(normsum,sctx->facenorm+3*fidx);
}
}
/* tvertB in input index space */
ELL_4MV_MUL(tvertB, sctx->txfIdx, tvertAsum);
/* tvertA in world space */
ELL_4MV_MUL(tvertA, sctx->shape->ItoW, tvertB);
ELL_4V_HOMOG(tvertA, tvertA);
ovi = airArrayLenIncr(bag->xyzwArr, 1);
ELL_4V_SET_TT(lpld->xyzw + 4*ovi, float,
tvertA[0], tvertA[1], tvertA[2], 1.0);
if (sctx->normalsFind) {
double len=ELL_3V_LEN(normsum);
airArrayLenIncr(bag->normArr, 1);
ELL_3V_SCALE_TT(lpld->norm + 3*ovi, float, 1.0/len, normsum);
}
sctx->vertNum++;
vii[0]=ovi;
vii[1]=sctx->vidx[3*(bag->evti[polygon[0]/3]+5*si)+polygon[0]%3];
for (j=0; j<polyct; ++j) {
double edgeA[3], edgeB[3];
double norm[3];
vii[2]=vii[1];
if (j==polyct-1) {
if (polygon[0]<36)
vii[1]=sctx->vidx[3*(bag->evti[polygon[0]/3] + 5*si)+
polygon[0]%3];
else vii[1]=sctx->facevidx[fvti[polygon[0]-36]];
} else {
if (polygon[j+1]<36)
vii[1]=sctx->vidx[3*(bag->evti[polygon[j+1]/3] + 5*si)+
polygon[j+1]%3];
else vii[1]=sctx->facevidx[fvti[polygon[j+1]-36]];
}
/* check for degenerate tris */
ELL_3V_SUB(edgeA, lpld->xyzw+4*vii[1], lpld->xyzw+4*vii[0]);
ELL_3V_SUB(edgeB, lpld->xyzw+4*vii[2], lpld->xyzw+4*vii[0]);
ELL_3V_CROSS(norm, edgeA, edgeB);
if (ELL_3V_DOT(norm,norm)!=0) {
unsigned iii = airArrayLenIncr(bag->indxArr, 3);
ELL_3V_COPY(lpld->indx + iii, vii);
lpld->icnt[0] += 3;
sctx->faceNum++;
}
/* else: degeneracies are caused by intersections that
* more or less coincide with a grid vertex. They
* should be harmless, so just don't create
* deg. triangles in this case */
}
} else if (polyct>2) {
/* insert the actual triangles */
unsigned int vii[3], iii;
if (polygon[0]<36)
vii[0]=sctx->vidx[3*(bag->evti[polygon[0]/3] + 5*si)+
polygon[0]%3];
else vii[0]=sctx->facevidx[fvti[polygon[0]-36]];
if (polygon[1]<36)
vii[1]=sctx->vidx[3*(bag->evti[polygon[1]/3] + 5*si)+
polygon[1]%3];
else vii[1]=sctx->facevidx[fvti[polygon[1]-36]];
if (polygon[2]<36)
vii[2]=sctx->vidx[3*(bag->evti[polygon[2]/3] + 5*si)+
polygon[2]%3];
else vii[2]=sctx->facevidx[fvti[polygon[2]-36]];
iii = airArrayLenIncr(bag->indxArr, 3);
ELL_3V_COPY(lpld->indx + iii, vii);
lpld->icnt[0] += 3;
sctx->faceNum++;
if (polyct==4) {
vii[1]=vii[2];
if (polygon[3]<36)
vii[2]=sctx->vidx[3*(bag->evti[polygon[3]/3] + 5*si)+
polygon[3]%3];
else vii[2]=sctx->facevidx[fvti[polygon[3]-36]];
iii = airArrayLenIncr(bag->indxArr, 3);
ELL_3V_COPY(lpld->indx + iii, vii);
lpld->icnt[0] += 3;
sctx->faceNum++;
}
}
}
}
}
}
}
return 0;
}
static void
shuffleT(seekContext *sctx, baggage *bag) {
unsigned int xi, yi, sx, sy, si;
sx = AIR_CAST(unsigned int, sctx->sx);
sy = AIR_CAST(unsigned int, sctx->sy);
if (sctx->strengthUse) { /* requests need to be cleared initially */
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
sctx->treated[xi+sx*yi] &= 0xFF^_SEEK_TREATED_REQUEST;
}
}
} /* else, the request bits are always on */
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
si = xi + sx*yi;
/* vidx neither needs past nor future context */
if (!bag->zi) {
ELL_3V_SET(sctx->vidx+3*(0+5*si), -1, -1, -1);
ELL_3V_SET(sctx->vidx+3*(1+5*si), -1, -1, -1);
} else {
ELL_3V_COPY(sctx->vidx+3*(0+5*si), sctx->vidx+3*(3+5*si));
ELL_3V_COPY(sctx->vidx+3*(1+5*si), sctx->vidx+3*(4+5*si));
}
ELL_3V_SET(sctx->vidx+3*(2+5*si),-1,-1,-1);
ELL_3V_SET(sctx->vidx+3*(3+5*si),-1,-1,-1);
ELL_3V_SET(sctx->vidx+3*(4+5*si),-1,-1,-1);
/* strength only has future context */
if (sctx->strengthUse) {
sctx->stng[0 + 2*si] = sctx->stng[1 + 2*si];
sctx->stng[1 + 2*si] = sctx->stngcontext[si];
if (sctx->stng[0+2*si]>sctx->strength ||
sctx->stng[1+2*si]>sctx->strength) {
/* set up to four request bits */
sctx->treated[si] |= _SEEK_TREATED_REQUEST;
if (xi!=0) sctx->treated[xi-1+sx*yi] |= _SEEK_TREATED_REQUEST;
if (yi!=0) sctx->treated[xi+sx*(yi-1)] |= _SEEK_TREATED_REQUEST;
if (xi!=0 && yi!=0)
sctx->treated[xi-1+sx*(yi-1)] |= _SEEK_TREATED_REQUEST;
}
}
/* shuffle grad, hess and t in three steps: move to past context,
* shuffle in slab itself, move from future context */
ELL_3V_COPY(sctx->gradcontext + 3*(0+2*si), sctx->grad + 3*(0+2*si));
ELL_3V_COPY(sctx->grad + 3*(0+2*si), sctx->grad + 3*(1+2*si));
ELL_3V_COPY(sctx->grad + 3*(1+2*si), sctx->gradcontext + 3*(1+2*si));
ELL_3M_COPY(sctx->hesscontext + 9*(0+2*si), sctx->hess + 9*(0+2*si));
ELL_3M_COPY(sctx->hess + 9*(0+2*si), sctx->hess + 9*(1+2*si));
ELL_3M_COPY(sctx->hess + 9*(1+2*si), sctx->hesscontext + 9*(1+2*si));
ELL_3M_COPY(sctx->tcontext + 9*(0+2*si), sctx->t + 9*(0+2*si));
ELL_3M_COPY(sctx->t + 9*(0+2*si), sctx->t + 9*(1+2*si));
ELL_3M_COPY(sctx->t + 9*(1+2*si), sctx->tcontext + 9*(1+2*si));
}
}
}
static void
probeT(seekContext *sctx, baggage *bag, double zi) {
unsigned int xi, yi, sx, sy, si;
sx = AIR_CAST(unsigned int, sctx->sx);
sy = AIR_CAST(unsigned int, sctx->sy);
for (yi=0; yi<sy; yi++) {
for (xi=0; xi<sx; xi++) {
si = xi + sx*yi;
if (sctx->gctx) { /* HEY: need this check, what's the right way? */
_seekIdxProbe(sctx, bag, xi, yi, zi);
}
if (sctx->strengthUse) {
sctx->stngcontext[si] = sctx->strengthSign*sctx->stngAns[0];
if (sctx->strengthSeenMax==AIR_NAN) {
sctx->strengthSeenMax = sctx->stngcontext[si];
}
sctx->strengthSeenMax = AIR_MAX(sctx->strengthSeenMax,
sctx->stngcontext[si]);
}
ELL_3V_COPY(sctx->gradcontext + 3*(1 + 2*si), sctx->gradAns);
ELL_3M_COPY(sctx->hesscontext + 9*(1 + 2*si), sctx->hessAns);
_seekHess2T(sctx->tcontext + 9*(1 + 2*si), sctx->evalAns, sctx->evecAns,
sctx->evalDiffThresh, (sctx->type==seekTypeRidgeSurfaceT));
}
}
}
/* it has now become much easier to make this its own routine
* (vs. adding many more case distinctions to shuffleProbe)
* this only duplicates little (and trivial) code */
int
_seekShuffleProbeT(seekContext *sctx, baggage *bag) {
/* for high-quality normal estimation, we need two slices of data
* context; to keep the code simple, separate shuffle and probe
* operations - let's hope this doesn't destroy cache performance */
if (!bag->zi) {
if (sctx->strengthUse)
/* before the first round, initialize treated to zero */
memset(sctx->treated, 0, sizeof(char)*sctx->sx*sctx->sy);
else /* request all edges */
memset(sctx->treated, _SEEK_TREATED_REQUEST,
sizeof(char)*sctx->sx*sctx->sy);
probeT(sctx, bag, 0);
shuffleT(sctx, bag);
probeT(sctx, bag, 1);
}
shuffleT(sctx, bag);
if (bag->zi!=sctx->sz-2)
probeT(sctx, bag, bag->zi+2);
intersectionShuffleProbe(sctx, bag);
return 0;
}
/* For all vertices in pld, use sctx to probe the strength measure,
* and return the answer (times strengthSign) in nval. The intended
* use is postfiltering (with limnPolyDataClip), which is obligatory
* when using seekType*SurfaceT
*
* Returns 1 and adds a message to biff upon error
* Returns 0 on success, -n when probing n vertices failed (strength
* is set to AIR_NAN for those); note that positions outside the field
* are clamped to lie on its boundary.
*
* This routine assumes that a strength has been set in sctx and
* seekUpdate() has been run.
* This routine does not modify sctx->strengthSeenMax.
*/
int
seekVertexStrength(Nrrd *nval, seekContext *sctx, limnPolyData *pld) {
static const char me[]="seekVertexStrength";
unsigned int i;
double *data;
int E=0;
if (!(nval && sctx && pld)) {
biffAddf(SEEK, "%s: got NULL pointer", me);
return 1;
}
if (!(sctx->gctx && sctx->pvl)) {
biffAddf(SEEK, "%s: need sctx with attached gageContext", me);
return 1;
}
if (!sctx->stngAns) {
biffAddf(SEEK, "%s: no strength item found. Did you enable strengthUse?",
me);
return 1;
}
if (nrrdAlloc_va(nval, nrrdTypeDouble, 1, (size_t) pld->xyzwNum)) {
biffAddf(SEEK, "%s: could not allocate output", me);
return 1;
}
data = (double*) nval->data;
for (i=0; i<pld->xyzwNum; i++) {
float homog[4];
ELL_4V_HOMOG(homog, pld->xyzw+4*i);
if (!gageProbeSpace(sctx->gctx,homog[0],homog[1],homog[2],0,1)) {
*(data++)=*(sctx->stngAns)*sctx->strengthSign;
} else {
*(data++)=AIR_NAN;
E--;
}
}
return E;
}
| code |
ਐੱਫ. ਐੱਸ. ਡੀ. ਏ.'] ", 'ਐੱਫ. ਐੱਸ. ਡੀ. ਏ. \n '] | punjabi |
Bridget (Bridie) Foley, 3 Abbot Crescent, Holycross, Thurles,and formerly Kerry and London. Deeply regretted by her loving sons Michael and Anthony, daughter Mary, grandchildren, great-grand child, son-in-law Calman, daughters-in-law Caroline and Julie, brother Willie, sister Annie, nieces, nephews, relatives and friends.
Reposing at Egan's Funeral Home, Thurles Sunday 2nd July 2017 from 5pm with removal at 7pm to Holycross Abbey. Requiem Mass Monday 3rd July 2017 at 11.30 and burial afterwards in Incharue Cemetery, Glencar, Co Kerry, arriving at 3.15pm approx. | english |
గీత దాటిన మీడియా.. హీరో నిఖిల్ ఆగ్రహం.. అక్కడ కెమెరాలు ఏంటంటూ..? దిశ, వెబ్డెస్క్: టాలీవుడ్ హీరో నిఖిల్ ఎప్పుడు సామజిక సమస్యలపై స్పందిస్తూ ఉంటాడు. తనకు నచ్చని విషయాన్నీ నిర్మొహమాటంగా చెప్పేస్తాడు. ట్విట్టర్ లో ఎప్పుడు యాక్టివ్ గా ఉండే నిఖిల్ తాజాగా సాయి ధరమ్ తేజ్ ఆక్సిడెంట్ విషయంలో మీడియా వేస్తోన్న వార్తలపై మండిపడ్డారు. సెలబ్రిటీల గురించి తెలుసుకోవాలనుకోవడం తప్పు లేదు.. కానీ, ఐసీయూ లో ఉన్నప్పుడు కూడా ప్రైవసీ ఇవ్వరా..? అంటూ ఆగ్రహం వ్యక్తం చేశాడు. సెప్టెంబర్ 10న మెగా మేనల్లుడు సాయి ధరమ్ తేజ్ రోడ్డు ప్రమాదానికి గురైన సంగతి తెలిసిందే. మాదాపూర్లో కొత్తగా నిర్మించిన కేబుల్ బ్రిడ్జి వద్ద స్పోర్ట్స్ బైక్పై నుంచి అదుపుతప్పి సాయి ధరమ్ తేజ్ కిందపడిపోవడంతో వెంటనే దగ్గరలోని మెడికోర్ ఆసుపత్రికి తరలించారు. అక్కడ నుండి అపోలోకి తరలించి చికిత్స అందిస్తున్నారు. తేజ్ కు ఐసీయూలో చికిత్స చేస్తున్న సమయంలో.. ఇక్కడ చూడండి. కళ్లు తెరవండి అంటూ వైద్యుడు సాయి ధరమ్ తేజ్ చేతిపై తడుతున్న వీడియో ఇటీవల బయటకు రావటం తెలిసిందే. దీనిపై నిఖిల్ ట్వీట్ చేస్తూ చికిత్స చేస్తున్న వీడియోలు బయటకు రావటం బాధాకరం.. ఐసీయూలో ఉన్నప్పుడైనా ఆ వ్యక్తికి గౌరవం ఇవ్వండి.. అక్కడ కూడా వారికి ప్రైవసీ లేదా..? ఐసీయూలోకి కెమెరాలను ఎలా అనుమతించారు? అని ప్రశ్నించారు. ప్రస్తుతం ఈ ట్వీట్ నెట్టింట వైరల్ గా మారింది. నిఖిల్ చెప్పిన దాంట్లోనూ వాస్తవం లేకపోలేదని, ప్రముఖుల వార్త కాబట్టి మీడియా ఇంకా ఎక్కువ చేస్తోందని నెటిజన్లు సైతం నిఖిల్ కి మద్దతు తెలుపుతున్నారు. కొన్నిసార్లు మీడియా గీత దాటుతోందని అభిప్రాయాలు వ్యక్తమవుతున్నాయి. | telegu |
// This may look like C code, but it's really -*- C++ -*-
/*
* Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
*
* See the LICENSE file for terms of use.
*/
#ifndef WT_DBO_QUERY_MODEL_IMPL_H_
#define WT_DBO_QUERY_MODEL_IMPL_H_
#include <Wt/Dbo/QueryColumn>
namespace Wt {
namespace Dbo {
template <class Result>
QueryModel<Result>::QueryModel(WObject *parent)
: WAbstractTableModel(parent),
batchSize_(40),
cachedRowCount_(-1),
cacheStart_(-1),
currentRow_(-1)
{ }
template <class Result>
void QueryModel<Result>::setQuery(const Query<Result>& query,
bool keepColumns)
{
queryLimit_ = query.limit();
queryOffset_ = query.offset();
if (!keepColumns) {
query_ = query;
fields_ = query_.fields();
columns_.clear();
reset();
} else {
invalidateData();
query_ = query;
fields_ = query_.fields();
dataReloaded();
}
}
template <class Result>
void QueryModel<Result>::setBatchSize(int count)
{
batchSize_ = count;
}
template <class Result>
int QueryModel<Result>::addColumn(const std::string& field,
const WString& header,
WFlags<ItemFlag> flags)
{
return addColumn(QueryColumn(field, header, flags));
}
template <class Result>
int QueryModel<Result>::addColumn(const std::string& field,
WFlags<ItemFlag> flags)
{
return addColumn(QueryColumn(field, WString::fromUTF8(field), flags));
}
template <class Result>
int QueryModel<Result>::addColumn(const QueryColumn& column)
{
columns_.push_back(column);
columns_.back().fieldIdx_ = getFieldIndex(column.field_);
return static_cast<int>(columns_.size() - 1);
}
template <class Result>
void QueryModel<Result>::addAllFieldsAsColumns()
{
for (unsigned i = 0; i < fields_.size(); ++i) {
WFlags<ItemFlag> flags = ItemIsSelectable;
if (fields_[i].isMutable())
flags |= ItemIsEditable;
if (fields_[i].qualifier().empty())
addColumn(fields_[i].name(), flags);
else
addColumn(fields_[i].qualifier() + "." + fields_[i].name(), flags);
}
}
template <class Result>
int QueryModel<Result>::columnCount(const WModelIndex& parent) const
{
if (parent.isValid())
return 0;
return static_cast<int>(columns_.size());
}
template <class Result>
int QueryModel<Result>::rowCount(const WModelIndex& parent) const
{
if (parent.isValid())
return 0;
if (cachedRowCount_ == -1) {
if (batchSize_)
cacheRow(0);
if (cachedRowCount_ == -1) {
Transaction transaction(query_.session());
query_.limit(queryLimit_);
query_.offset(queryOffset_);
cachedRowCount_ = static_cast<int>(query_.resultList().size());
transaction.commit();
}
}
return cachedRowCount_;
}
template <class Result>
WFlags<ItemFlag> QueryModel<Result>::flags(const WModelIndex& index) const
{
return columns_[index.column()].flags_;
}
template <class Result>
boost::any QueryModel<Result>::data(const WModelIndex& index, int role) const
{
setCurrentRow(index.row());
if (role == DisplayRole || role == EditRole)
return rowValues_[columns_[index.column()].fieldIdx_];
else
return boost::any();
}
template <class Result>
void QueryModel<Result>::setCurrentRow(int row) const
{
if (currentRow_ != row) {
Transaction transaction(query_.session());
const Result& result = resultRow(row);
rowValues_.clear();
query_result_traits<Result>::getValues(result, rowValues_);
currentRow_ = row;
transaction.commit();
}
}
template <class Result>
bool QueryModel<Result>::setData(const WModelIndex& index,
const boost::any& value, int role)
{
if (role == EditRole) {
Transaction transaction(query_.session());
Result& result = resultRow(index.row());
int column = columns_[index.column()].fieldIdx_;
const FieldInfo& field = fields()[column];
boost::any dbValue = Wt::convertAnyToAny(value, *field.type());
query_result_traits<Result>::setValue(result, column, dbValue);
invalidateRow(index.row());
transaction.commit();
return true;
} else
return false;
}
template <class Result>
void QueryModel<Result>::invalidateData()
{
layoutAboutToBeChanged().emit();
cachedRowCount_ = cacheStart_ = currentRow_ = -1;
cache_.clear();
rowValues_.clear();
stableIds_.clear();
}
template <class Result>
void QueryModel<Result>::dataReloaded()
{
layoutChanged().emit();
}
template <class Result>
void QueryModel<Result>::sort(int column, SortOrder order)
{
/*
* This should not change the row count
*/
int rc = cachedRowCount_;
invalidateData();
query_.orderBy(fields_[columns_[column].fieldIdx_].sql() + " "
+ (order == AscendingOrder ? "asc" : "desc"));
cachedRowCount_ = rc;
dataReloaded();
}
template <class Result>
Result QueryModel<Result>::stableResultRow(int row) const
{
StableResultIdMap::const_iterator i = stableIds_.find(row);
if (i != stableIds_.end())
return resultById(i->second);
else
return resultRow(row);
}
template <class Result>
Result& QueryModel<Result>::resultRow(int row)
{
cacheRow(row);
if (row >= cacheStart_ + static_cast<int>(cache_.size()))
throw Exception("QueryModel: geometry inconsistent with database");
return cache_[row - cacheStart_];
}
template <class Result>
void QueryModel<Result>::cacheRow(int row) const
{
if (row < cacheStart_
|| row >= cacheStart_ + static_cast<int>(cache_.size())) {
cacheStart_ = std::max(row - batchSize_ / 4, 0);
int qOffset = cacheStart_;
if (queryOffset_ > 0)
qOffset += queryOffset_;
query_.offset(qOffset);
int qLimit = batchSize_;
if (queryLimit_ > 0)
qLimit = std::min(batchSize_, queryLimit_ - cacheStart_);
query_.limit(qLimit);
Transaction transaction(query_.session());
collection<Result> results = query_.resultList();
cache_.clear();
cache_.insert(cache_.end(), results.begin(), results.end());
for (unsigned i = 0; i < cache_.size(); ++i) {
long long id = resultId(cache_[i]);
if (id != -1)
stableIds_[cacheStart_ + i] = id;
}
if (static_cast<int>(cache_.size()) < qLimit
&& qOffset == 0 && cachedRowCount_ == -1)
cachedRowCount_ = cache_.size();
transaction.commit();
}
}
template <class Result>
void QueryModel<Result>::invalidateRow(int row)
{
if (row == currentRow_)
currentRow_ = -1;
WModelIndex start = index(row, 0);
WModelIndex end = index(row, columnCount() - 1);
dataChanged().emit(start, end);
}
template <class Result>
const Result& QueryModel<Result>::resultRow(int row) const
{
return const_cast<const Result&>
(const_cast<QueryModel<Result> *>(this)->resultRow(row));
}
template <class Result>
void QueryModel<Result>::reload()
{
invalidateData();
dataReloaded();
}
template <class Result>
int QueryModel<Result>::getFieldIndex(const std::string& field)
{
for (unsigned i = 0; i < fields_.size(); ++i) {
if (fields_[i].name() == field)
return i;
if (!fields_[i].qualifier().empty())
if (fields_[i].qualifier() + "." + fields_[i].name() == field)
return i;
}
throw Exception("QueryModel: could not find field: '" + field + "'");
}
template <class Result>
const std::vector<FieldInfo>& QueryModel<Result>::fields() const
{
return fields_;
}
template <class Result>
const FieldInfo &QueryModel<Result>::fieldInfo(int column) const
{
return fields_[columns_[column].fieldIdx_];
}
template <class Result>
const std::string &QueryModel<Result>::fieldName(int column) const
{
return columns_[column].field_;
}
template <class Result>
WFlags<ItemFlag> QueryModel<Result>::columnFlags(int column) const
{
return columns_[column].flags_;
}
template <class Result>
void QueryModel<Result>::setColumnFlags(int column, WFlags<ItemFlag> flags)
{
columns_[column].flags_ = flags;
}
template <class Result>
Result QueryModel<Result>::createRow()
{
return query_result_traits<Result>::create();
}
template <class Result>
void QueryModel<Result>::addRow(Result& result)
{
query_result_traits<Result>::add(query_.session(), result);
}
template <class Result>
void QueryModel<Result>::deleteRow(Result& result)
{
query_result_traits<Result>::remove(result);
}
template <class Result>
bool QueryModel<Result>::insertRows(int row, int count,
const WModelIndex& parent)
{
if (row != rowCount())
throw Exception("QueryModel: only supporting row insertion at end");
beginInsertRows(parent, row, row + count - 1);
for (int i = 0; i < count; ++i) {
Result r = createRow();
addRow(r);
/*
* Insert also into cache, this avoids a useless insert+query
* when insertion is followed by setData() calls.
*/
if (cacheStart_ != -1
&& cacheStart_ + (int)cache_.size() == row + i)
cache_.push_back(r);
}
cachedRowCount_ += count;
endInsertRows();
return true;
}
template <class Result>
bool QueryModel<Result>::removeRows(int row, int count,
const WModelIndex& parent)
{
beginRemoveRows(parent, row, row + count - 1);
for (int i = 0; i < count; ++i) {
deleteRow(resultRow(row));
cache_.erase(cache_.begin() + (row - cacheStart_));
}
cachedRowCount_ -= count;
endRemoveRows();
return true;
}
template <class Result>
bool QueryModel<Result>::setHeaderData(int section, Orientation orientation,
const boost::any& value,
int role)
{
if (orientation == Horizontal) {
if (role == EditRole)
role = DisplayRole;
columns_[section].headerData_[role] = value;
return true;
} else
return WAbstractTableModel::setHeaderData(section, orientation,
value, role);
}
template <class Result>
boost::any QueryModel<Result>::headerData(int section, Orientation orientation,
int role) const
{
if (orientation == Horizontal) {
if (role == LevelRole)
return WAbstractTableModel::headerData(section, orientation, role);
QueryColumn::HeaderData::const_iterator i
= columns_[section].headerData_.find(role);
if (i != columns_[section].headerData_.end())
return i->second;
else
return boost::any();
} else
return WAbstractTableModel::headerData(section, orientation, role);
}
template <class Result>
long long QueryModel<Result>::resultId(const Result& result) const
{
return query_result_traits<Result>::id(result);
}
template <class Result>
Result QueryModel<Result>::resultById(long long id) const
{
Transaction transaction(query_.session());
return query_result_traits<Result>::findById(query_.session(), id);
}
template <class Result>
void *QueryModel<Result>::toRawIndex(const WModelIndex& index) const
{
if (index.isValid()) {
long long id = resultId(resultRow(index.row()));
if (id >= 0)
return reinterpret_cast<void *>(id + 1);
else
return 0;
} else
return 0;
}
template <class Result>
WModelIndex QueryModel<Result>::fromRawIndex(void *rawIndex) const
{
if (rawIndex) {
long long id = reinterpret_cast<long long>(rawIndex) - 1;
for (int row = 0; row < std::min(rowCount(), batchSize_); ++row) {
const Result& result = resultRow(row);
if (resultId(result) == id)
return index(row, 0);
}
}
return WModelIndex();
}
}
}
#endif // WT_DBO_QUERY_MODEL_IMPL_H_
| code |
UPમાં EVM બદલાયાં હોવાના કારણે 142 બેઠકો પર ફરી કરાવાશે મતદાન ? જાણો ચૂંટણી પંચે શું કહ્યું ? નવી દિલ્હીઃ હાલમાં પાંચ રાજ્યોમાં ચૂંટણી પૂરી થઈ છે. આ ચૂંટણીમાં કુલ 4 રાજ્યોમાં ભાજપની સરકારે સત્તા મેળવી છે. જેમાં યુપીમાં પણ ભાજપની સરકાર બની છે. ત્યારે હવે સોશિયલ મીડિયા પર એક મેસેજ વાયરલ થયો છે. જેમાં કહેવામાં આવી રહ્યું છે કે, યૂપીમાં ઈવીએમ બદલવાને કારણે હવે 142 બેઠકો પર ફરીથી ચૂંટણી કરનાવાવના આદેશ આપવામાં આવ્યા છે. વાયરલ મેસેટમાં એક તસવીર શેર કરવામાં આવી રહી છે જે નેશનલ ટીવીની યૂટ્યુબ ચેનલનો થમ્બનેલ ફોટો છે. આ વાયરલ મેસેજ અનુસાર પ્રકાશિત વીડિયોમાં એક ઓડિયો ક્લિપમાં ચૂંટણીમાં ધાંધલ ધમાલ અને ચૂંટણી પંચ દ્વારા 142 બેઠકો પર ફરીથી ચૂંટણી કરાવવાનો દાવો કરવામાં આવ્યો છે. જોકે આ મામલે ભારત સરકારના પીઆઈબી ફેક્ટ ચેક દ્વારા તપાસ કરવામાં આવી છે અને આ વાયરલ મેસેજને ખોટો ગણાવવામાં આવ્યો છે. સરકારી ફેક્ટ ચેકિંગ સંસ્થા PIB ફેક્ટ ચેકે પણ પોતાની તપાસમાં આ દાવાને ખોટો ગણાવ્યો છે. પીઆઈબી ફેક્ટ ચેકે ટ્વીટ કરીને કહ્યું છે કે, નકલી તસવીર દ્વારા દાવો કરવામાં આવી રહ્યો છે કે EVM બદલવાના કારણે 142 સીટો પર ફરીથી ચૂંટણી થશે. PIBFactCheck. ઈવીએમ બદલવાનો દાવો ખોટો છે. ECISVEEP દ્વારા 142 બેઠકો માટે પુનઃ મતદાનની જાહેરાત કરવામાં આવી નથી. મહેરબાની કરીને આવા ભ્રામક વિડિયો શેર કરશો નહીં PIB ફેક્ટ ચેક શું છે ? નોંધનીય છે કે, પીઆઈબી ફેક્ટ ચેક કેન્દ્ર સરકારની પોલિસી સ્કીમ, વિભાગો, મંત્રાલયોને લઈને ફેલાતી ખોટી સૂચનાઓને રોકવા માટેનું કામ કરે છે. સરકારથી જોડાયેલી કોઈ પણ ખબર સાચી છે કે ખોટી તે જાણવા માટે પીઆઈબી ફેક્ટ ચેકની મદદ લઈ શકાય છે. કોઈ પણ પીઆઈબી ફેક્ટ ચેકનો સંદેહાત્મક સમાચારનો સ્ક્રિનશોટ, ટ્વિટ, ફેસબુક પોસ્ટ અથવા યુઆરએલ વોટ્સએપ નંબર 918799711259 પર મોકલી શકો છો. અથવા પછી pibfactcheckgmail.com પર મેઈલ કરી શકો છો. | gujurati |
नाबालिग के दैहिक शोषण के मामले में कोचिंग संचालक गिरफ्तार बड़वानी . मध्यप्रदेश Madhya Pradesh के बड़वानी जिले के अंजड़ में एक नाबालिग छात्रा के दैहिक शोषण के मामले में पांच महीने से फरार कोचिंग क्लास संचालक को गिरफ्तार कर लिया गया है. अंजड़ की थाना प्रभारी सोनू शितोले ने आज शाम बताया कि कोचिंग क्लास संचालक ने कल बड़वानी के पोक्सो कोर्ट के समक्ष आत्मसमर्पण कर दिया था. उसका एक दिन का पुलिस Police रिमांड प्राप्त करने के बाद आज उसे पुनः न्यायालय के समक्ष पेश किया गया, जहां से उसे न्यायिक हिरासत में भेज दिया गया. यूक्रेन में फंसी छात्रा की मां से ठगी का आरोपी गिरफ्तार उन्होंने बताया कि आरोपी इस दौरान उत्तर प्रदेश Uttar Pradesh के प्रयागराज Prayagrajमें निवासरत रहा. मूलतः उत्तर प्रदेश Uttar Pradesh के कानपुर Kanpur क्षेत्र के निवासी आरोपी का परिवार फिलहाल पिछले कई वर्षों से इंदौर Indore में निवासरत है. आरोपी कोचिंग क्लास संचालक कक्षा 10 की छात्रा को गणित विषय में कमजोर बताते हुए इसे बेहतर करने के लिए कोचिंग के बाद अतिरिक्त पढ़ाई के नाम पर रोक लेता था तथा बहलाफुसलाकर उसका दैहिक शोषण करता था. न्यूज अच्छी लगी हो तो कृपया शेयर जरूर करें ऐसी ही और लोकल खबरों के लिए, डाउनलोड करें हमारा नया लोकल वीडियो ऐप पब्लिक वाइब | hindi |
ജോജുവിനെതിരേ കേസെടുത്തില്ലെങ്കില് കോടതിയെ സമീപിക്കും: മുഹമ്മദ് ഷിയാസ് കൊച്ചി: ജോജു ജോര്ജിനെതിരേ കേസെടുത്തില്ലെങ്കില് കോടതിയെ സമീപിക്കുമെന്ന് എറണാകുളം ഡിസിസി പ്രസിഡന്റ് മുഹമ്മദ് ഷിയാസ്. പ്രതിഷേധ സമരത്തിനിടെ പ്രശ്നമുണ്ടാക്കുകയും,സ്ത്രീകള്ക്ക് കേള്ക്കാന് കൊള്ളാല്ലാത്ത ചീത്ത വിളിക്കുകയും ചെയ്ത ജോജുവിനെതിരെ എന്തു കൊണ്ട് കേസെടുക്കുന്നില്ലെന്നും അദ്ദേഹം ചോദിച്ചു. പോലീസിന്റേത് ഏകപക്ഷീയ നിലപാടാണെന്നും അദ്ദേഹം ആരോപിച്ചു.ചീത്ത പറഞ്ഞുകൊണ്ടാണ് ജോജു ജോര്ജ് പ്രവര്ത്തകര്ക്കടുത്തേക്ക് വന്നതെന്ന് ഷിയാസ് ആരോപിച്ചു. മാന്യതയുടെ ഒരു സ്വരംപോലും ഈ സമൂഹത്തോട് പ്രതിബദ്ധതയുള്ള ഒരു കലാകാരന് ഇല്ല. സ്ത്രീകളെ തള്ളുകയും ചെയ്തു. സ്ത്രീകള് കൊടുത്ത പരാതിയില് എന്തു കൊണ്ട് കേസെടുക്കുന്നില്ലെന്നും അദ്ദേഹം ചോദിച്ചു. സാധാരണക്കാര്ക്കു വേണ്ടിയാണ് അവിടെ പ്രതിഷേധിച്ചത്.110 രൂപയ്ക്ക് പെട്രോള് വാങ്ങാന് പറ്റാത്ത സാധാരണക്കാരുടെ പ്രതിഷേധമാണ് അവിടെ നടന്നത്,അവര്ക്ക് മുന്നില് തോന്ന്യവാസം പറഞ്ഞാല് അവര് പ്രതികരിച്ചുപോകുമെന്നും ഷിയാസ് പ്രതികരിച്ചു. | malyali |
A modern comedy by one of Britain's best contemporary playwrights.
The actors playing Oberon and Titania in “Midsummer Night’s Dream” are about to marry in real life. Some tourists arrive from Germany, the USA and Japan, all admirers of the Bard. A struggling playwright, his would-be-actress girlfriend and a new age traveller complete the cast. Everyone rushes into the woods. Confusion ensues, as effects of a “friendly-tablet” taken in coffee causes mistaken identities in this fast paced comedy. | english |
Photo Booth International is a unique Photo Booth & Photo Kiosk manufacturing company based in Dallas, TX. We specialize in creating cutting edge products that make a memorable experience for each of our users. Our custom Photo Booths draws crowds at any location whether you have it at a wedding or inside a restaurant, it always turns heads.
We sell to entrepreneurs who want to quit the 9-5 rat race and start something great. We provide lifetime tech support and a free website with every purchase and every tool you need to start a profitable Photo Booth Business. Our goal is to make sure you are successful so you can buy another booth from us. Most of our client pay of their investments in 6-8months.
This podcast is packed with applicable content. Easy to follow concepts and understand speaker.
Great info for someone who is getting started.
Just started my photo booth business so the info helps out a lot thanks guys.
Jason Whaley & Tim Smith: Photo Booth Enthusiast. | english |
FarhanShibani Wedding: मेहंदी फंक्शन में Rhea Chakraborty ने Anushka Dandekar के साथ लगाए ठुमके, मेहंदी लगा के रखना पर किया डांस FarhanShibani Mehendi:फरहान अख्तर और शिबानी दांडेकर की शादी के फंक्शन शुरू हो चुके हैं. हाल ही में मेहंदी सेरेमनी हुई थी. जिसमें शिबानी की खास दोस्त रिया चक्रवर्ती Rhea Chakraborty ने डांस किया था. Farhan AkhtarShibani Dandekar Mehendi: बॉलीवुड एक्टर फरहान अख्तर Farhan Akhtar और शिबानी दांडेकर Shibani Dandekar शादी के बंधन में बंधने के लिए तैयार हैं. दोनों 21 फरवरी को शादी करने जा रहे हैं. फरहान और शिबानी की शादी के प्रीवेडिंग फंक्शन शुरू हो चुके हैं. फरहान और शिबानी के मेहंदी फ्क्शन में उनकी खास दोस्त रिया चक्रवर्ती Rhea Chakraborty, अनुषा दांडेकर Anusha Dandekar और अपेक्षा दांडेकर शामिल हुए थे. उन्होंने इस फंक्शन में डांस किया था. जिसकी वीडियो सोशल मीडिया पर खूब वायरल हो रही है. फरहान और शिबानी की शादी का फैंस को बेसब्री से इंतजार था. बॉलीवुड में शादियों का सीजन चल रहा है. कई सेलेब्स शादी के बंधन में बंध चुके हैं और अब फरहानशिबानी की बारी है. फरहान और शिबानी की शादी के बारे में खुद जावेद अख्तर ने कंफर्म किया था. डांस वीडियो हुआ वायरल फरहान और शिबानी के फंक्शन में अनुषा, अपेक्षा और रिया ने दिलवाले दुल्हनिया ले जाएंगे के आइकॉनिक गाने मेहंदी लगा के रखना पर डांस करते नजर आ रहे हैं. रिया के डांस का ये वीडियो सोशल मीडिया पर खूब वायरल हो रहा है. ये फंक्शन फरहान के मुंबई वाले घर पर हुआ था. इस फंक्शन में शबाना आजमी, अमृता अरोड़ा सहित कई सेलेब्स शामिल हुए थे. फरहान ने हाल ही में अपनी बैचलर पार्टी की तस्वीर सोशल मीडिया पर शेयर की थी. जिसमें फरहान अपने दोस्तों के साथ पोज देते नजर आ रहे थे. इस फोटो में फरहान और शिबानी के चेहरों का कटआउट भी नजर आ रहा था. फोटोज में फरहान के खास दोस्त रितेश सिद्धवानी और शकील भी थे. आपको बता दें जावेद अख्तर ने एक इंटरव्यू में कहा था कि फरहान और शिबानी शादी करने जा रहे हैं. शादी की जो तैयारियां हैं वह वेडिंग प्लानर देख रहे हैं. ये इंटीमेट सेरेमनी होगी. महामारी की सिचुएशन देखते हुए हम शादी बड़े स्केल पर नहीं कर सकते हैं. शादी में कुछ ही लोग शामिल होने वाले हैं. Watch: तिवारी जी Rohitashv Gour का Pushpa अवतार देख भड़की रुसा, कर डाली धुलाई | hindi |
नियम 134ए : दूसरे ड्रा में 375 विद्यार्थियों के नाम, 18 तक ले सकेंगे दाखिला भिवानी। शिक्षा विभाग की ओर से नियम 134ए के तहत विभिन्न निजी स्कूलों की खाली सीटों पर दाखिला प्रक्रिया जारी है। विभाग ने इसके लिए दूसरा ड्रा जारी किया है, जिसमें 375 विद्यार्थियों के नाम जारी हुए हैं। ये विद्यार्थी 18 फरवरी तक अपने अलॉट हुए स्कूलों में दस्तावेज जमा करवाकर दाखिल ले सकते हैं। वहीं, शिक्षा अधिकारियों के दखल के बाद अब पहले ड्रा में वंचित 100 विद्यार्थियों भी दाखिला मिल चुका है। नियम 134ए के तहत जिले में वर्ष 2021 में 2558 विद्यार्थियों ने परीक्षा उत्तीर्ण की थी, जिनमें से 1308 विद्यार्थियों को दाखिला मिलना था। निजी स्कूलों ने इनमें से 100 से अधिक बच्चों को पात्र होते हुए भी दाखिला देने से मना कर दिया। इस संबंध में अभिभावकों ने खंड शिक्षा अधिकारी को शिकायत की। इसके बाद शिक्षा अधिकारियों ने मामले की जांच की, जिसके बाद बच्चों को दाखिला मिल पाया। पहले ड्रा में हुआ 1308 विद्यार्थियों का दाखिला नियम 134ए के तहत जिले से 4349 विद्यार्थियों ने आवेदन किया था, जिनमें से 2558 विद्यार्थियों ने परीक्षा उत्तीर्ण की। इन विद्यार्थियों को जिले के निजी स्कूलों में दाखिला के लिए ऑनलाइन सूची उपलब्ध करवाई गई। साथ ही स्कूल के बाहर भी पात्र विद्यार्थियों की सूची लगवाई। पहले ड्रा में 2183 विद्यार्थियों की सूची जारी हुई थी। इनमें से 1308 विद्यार्थियों को पहले ड्रा में दाखिला मिला, जबकि 875 विद्यार्थियों के दस्तावेजों में त्रुटि होने की वजह से उनका दाखिला नहीं हो सका। इनमें से अधिकतर ने आय प्रमाण पत्र में गलती की हुई थी। एसोसिएशन ने किया विरोध तो अभिभावक ने काटे बीईओ ऑफिस के चक्कर नियम 134ए के तहत विद्यार्थियों का निजी स्कूलों में निशुल्क दाखिला देने को लेकर प्राइवेट स्कूल वेलफेयर एसोसिएशन ने भी विरोध किया था। एसोसिएशन ने सरकार को उनकी मांगों का पूरा करने और बकाया राशि जारी करने की मांग की थी। इस दौरान अभिभावकों को उनके बच्चों के दाखिला का डर सता रहा था। अपने बच्चों का दाखिला करवाने के लिए अभिभावक कभी निजी स्कूल तो कभी खंड शिक्षा अधिकारी के कार्यालय में चक्कर काट रहे थे। इसको लेकर शिक्षा विभाग की ओर से निजी स्कूलों को चेतावनी नोटिस भी जारी किए गए, जिनमें उनकी मान्यता रद्द करने तक के दावे कर दिए थे। इसके बाद सरकार ने एसोसिएशन से इस संबंध में वार्ता कर समस्या का समाधान किया था, जिसके बाद अभिभावकों और शिक्षा अधिकारियों ने चैन की सांस ली। यह दस्तावेज जरूरी नियम 134ए के तहत दाखिल आवेदन के इच्छुक विद्यार्थियों को बच्चे का आधार कार्ड, जन्म प्रमाण पत्र, बीपीएल कार्ड या अभिभावक का दो लाख रुपये से कम का आय प्रमाण पत्र, बच्चा जिस स्कूल में पहले पढ़ रहा है उस स्कूल से बच्चे का एसआरएन नंबर, स्कूल का कोड व अभिभावक का मोबाइल नंबर जरूरी है। नियम 134 के तहत दाखिला प्रक्रिया जारी है। विभाग की ओर से दूसरा ड्रा जारी किया जा चुका है, जिनके पात्र विद्यार्थी दाखिला लेने में जुटे हुए है। पहले ड्रा के कुछ पात्र विद्यार्थियों को निजी स्कूलों ने दाखिला देने से मना कर दिया था, जिसको लेकर अभिभावकों ने जिला मुख्यालय पर शिकायत दी थी। शिकायत मिलते है इस समस्या का तुरंत प्रभाव से समाधान करवाया दिया था। रामअवतार शर्मा, जिला मौलिक शिक्षा अधिकारी। | hindi |
.rc-tree-select {
box-sizing: border-box;
display: inline-block;
position: relative;
vertical-align: middle;
color: #666;
}
.rc-tree-select ul,
.rc-tree-select li {
margin: 0;
padding: 0;
list-style: none;
}
.rc-tree-select > ul > li > a {
padding: 0;
background-color: #fff;
}
.rc-tree-select-arrow {
height: 26px;
position: absolute;
top: 1px;
right: 1px;
width: 20px;
}
.rc-tree-select-arrow b {
border-color: #999999 transparent transparent transparent;
border-style: solid;
border-width: 5px 4px 0 4px;
height: 0;
width: 0;
margin-left: -4px;
margin-top: -2px;
position: absolute;
top: 50%;
left: 50%;
}
.rc-tree-select-selection {
outline: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
-webkit-user-select: none;
box-sizing: border-box;
display: block;
background-color: #fff;
border-radius: 6px;
border: 1px solid #d9d9d9;
}
.rc-tree-select-enabled .rc-tree-select-selection:hover {
border-color: #23c0fa;
box-shadow: 0 0 2px rgba(45, 183, 245, 0.8);
}
.rc-tree-select-enabled .rc-tree-select-selection:active {
border-color: #2db7f5;
}
.rc-tree-select-selection--single {
height: 28px;
cursor: pointer;
position: relative;
}
.rc-tree-select-selection--single .rc-tree-select-selection__rendered {
display: block;
padding-left: 10px;
padding-right: 20px;
line-height: 28px;
}
.rc-tree-select-selection--single .rc-tree-select-selection-selected-value {
display: block;
overflow: hidden;
white-space: nowrap;
text-overflow: ellipsis;
}
.rc-tree-select-selection--single .rc-tree-select-selection__clear {
font-weight: bold;
position: absolute;
top: 5px;
right: 20px;
}
.rc-tree-select-selection--single .rc-tree-select-selection__clear:after {
content: '×';
}
.rc-tree-select-disabled {
color: #ccc;
cursor: not-allowed;
}
.rc-tree-select-disabled .rc-tree-select-selection--single,
.rc-tree-select-disabled .rc-tree-select-selection__choice__remove {
cursor: not-allowed;
color: #ccc;
}
.rc-tree-select-disabled .rc-tree-select-selection--single:hover,
.rc-tree-select-disabled .rc-tree-select-selection__choice__remove:hover {
cursor: not-allowed;
color: #ccc;
}
.rc-tree-select-search__field__wrap {
display: inline-block;
position: relative;
}
.rc-tree-select-search__field__placeholder {
position: absolute;
top: 0;
left: 3px;
color: #aaa;
}
.rc-tree-select-search--inline {
float: left;
width: 100%;
}
.rc-tree-select-search--inline .rc-tree-select-search__field__wrap {
width: 100%;
}
.rc-tree-select-search--inline .rc-tree-select-search__field {
border: none;
font-size: 100%;
background: transparent;
outline: 0;
width: 100%;
}
.rc-tree-select-search--inline > i {
float: right;
}
.rc-tree-select-enabled.rc-tree-select-selection--multiple {
cursor: text;
}
.rc-tree-select-selection--multiple {
min-height: 28px;
}
.rc-tree-select-selection--multiple .rc-tree-select-search--inline {
width: auto;
}
.rc-tree-select-selection--multiple .rc-tree-select-search--inline .rc-tree-select-search__field {
width: 0.75em;
}
.rc-tree-select-selection--multiple .rc-tree-select-search__field__placeholder {
top: 5px;
left: 8px;
}
.rc-tree-select-selection--multiple .rc-tree-select-selection__rendered {
overflow: hidden;
text-overflow: ellipsis;
padding-left: 8px;
padding-bottom: 2px;
}
.rc-tree-select-selection--multiple > ul > li {
margin-top: 4px;
height: 20px;
line-height: 20px;
}
.rc-tree-select-enabled .rc-tree-select-selection__choice {
cursor: default;
}
.rc-tree-select-enabled .rc-tree-select-selection__choice:hover .rc-tree-select-selection__choice__remove {
opacity: 1;
-webkit-transform: scale(1);
transform: scale(1);
}
.rc-tree-select-enabled .rc-tree-select-selection__choice:hover .rc-tree-select-selection__choice__remove + .rc-tree-select-selection__choice__content {
margin-left: -8px;
margin-right: 8px;
}
.rc-tree-select .rc-tree-select-selection__choice {
background-color: #f3f3f3;
border-radius: 4px;
float: left;
padding: 0 15px;
margin-right: 4px;
position: relative;
overflow: hidden;
-webkit-transition: padding 0.3s cubic-bezier(0.6, -0.28, 0.735, 0.045), width 0.3s cubic-bezier(0.6, -0.28, 0.735, 0.045);
transition: padding 0.3s cubic-bezier(0.6, -0.28, 0.735, 0.045), width 0.3s cubic-bezier(0.6, -0.28, 0.735, 0.045);
}
.rc-tree-select .rc-tree-select-selection__choice__content {
margin-left: 0;
margin-right: 0;
-webkit-transition: margin 0.3s cubic-bezier(0.165, 0.84, 0.44, 1);
transition: margin 0.3s cubic-bezier(0.165, 0.84, 0.44, 1);
}
.rc-tree-select .rc-tree-select-selection__choice-zoom-enter,
.rc-tree-select .rc-tree-select-selection__choice-zoom-appear,
.rc-tree-select .rc-tree-select-selection__choice-zoom-leave {
-webkit-animation-duration: .3s;
animation-duration: .3s;
-webkit-animation-fill-mode: both;
animation-fill-mode: both;
-webkit-transform-origin: 0 0;
transform-origin: 0 0;
opacity: 0;
-webkit-animation-play-state: paused;
animation-play-state: paused;
-webkit-animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1.275);
animation-timing-function: cubic-bezier(0.175, 0.885, 0.32, 1.275);
}
.rc-tree-select .rc-tree-select-selection__choice-zoom-leave {
opacity: 1;
-webkit-animation-timing-function: cubic-bezier(0.6, -0.28, 0.735, 0.045);
animation-timing-function: cubic-bezier(0.6, -0.28, 0.735, 0.045);
}
.rc-tree-select .rc-tree-select-selection__choice-zoom-enter.rc-tree-select-selection__choice-zoom-enter-active,
.rc-tree-select .rc-tree-select-selection__choice-zoom-appear.rc-tree-select-selection__choice-zoom-appear-active {
-webkit-animation-play-state: running;
animation-play-state: running;
-webkit-animation-name: rcSelectChoiceZoomIn;
animation-name: rcSelectChoiceZoomIn;
}
.rc-tree-select .rc-tree-select-selection__choice-zoom-leave.rc-tree-select-selection__choice-zoom-leave-active {
-webkit-animation-play-state: running;
animation-play-state: running;
-webkit-animation-name: rcSelectChoiceZoomOut;
animation-name: rcSelectChoiceZoomOut;
}
@-webkit-keyframes rcSelectChoiceZoomIn {
0% {
-webkit-transform: scale(0.6);
transform: scale(0.6);
opacity: 0;
}
100% {
-webkit-transform: scale(1);
transform: scale(1);
opacity: 1;
}
}
@keyframes rcSelectChoiceZoomIn {
0% {
-webkit-transform: scale(0.6);
transform: scale(0.6);
opacity: 0;
}
100% {
-webkit-transform: scale(1);
transform: scale(1);
opacity: 1;
}
}
@-webkit-keyframes rcSelectChoiceZoomOut {
to {
-webkit-transform: scale(0);
transform: scale(0);
opacity: 0;
}
}
@keyframes rcSelectChoiceZoomOut {
to {
-webkit-transform: scale(0);
transform: scale(0);
opacity: 0;
}
}
.rc-tree-select .rc-tree-select-selection__choice__remove {
color: #919191;
cursor: pointer;
font-weight: bold;
padding: 0 0 0 8px;
position: absolute;
opacity: 0;
-webkit-transform: scale(0);
transform: scale(0);
top: 0;
right: 2px;
-webkit-transition: opacity .3s, -webkit-transform .3s;
transition: opacity .3s, -webkit-transform .3s;
transition: opacity .3s, transform .3s;
transition: opacity .3s, transform .3s, -webkit-transform .3s;
}
.rc-tree-select .rc-tree-select-selection__choice__remove:before {
content: '×';
}
.rc-tree-select .rc-tree-select-selection__choice__remove:hover {
color: #333;
}
.rc-tree-select-dropdown {
background-color: white;
border: 1px solid #d9d9d9;
box-shadow: 0 0px 4px #d9d9d9;
border-radius: 4px;
box-sizing: border-box;
z-index: 100;
left: -9999px;
top: -9999px;
position: absolute;
outline: none;
}
.rc-tree-select-dropdown-hidden {
display: none;
}
.rc-tree-select-dropdown-menu {
outline: none;
margin: 0;
padding: 0;
list-style: none;
z-index: 9999;
}
.rc-tree-select-dropdown-menu > li {
margin: 0;
padding: 0;
}
.rc-tree-select-dropdown-menu-item-group-list {
margin: 0;
padding: 0;
}
.rc-tree-select-dropdown-menu-item-group-list > li.rc-tree-select-menu-item {
padding-left: 20px;
}
.rc-tree-select-dropdown-menu-item-group-title {
color: #999;
line-height: 1.5;
padding: 8px 10px;
border-bottom: 1px solid #dedede;
}
li.rc-tree-select-dropdown-menu-item {
margin: 0;
position: relative;
display: block;
padding: 7px 10px;
font-weight: normal;
color: #666666;
white-space: nowrap;
}
li.rc-tree-select-dropdown-menu-item-selected {
background-color: #ddd;
}
li.rc-tree-select-dropdown-menu-item-active {
background-color: #5897fb;
color: white;
cursor: pointer;
}
li.rc-tree-select-dropdown-menu-item-disabled {
color: #ccc;
cursor: not-allowed;
}
li.rc-tree-select-dropdown-menu-item-divider {
height: 1px;
margin: 1px 0;
overflow: hidden;
background-color: #e5e5e5;
line-height: 0;
}
.rc-tree-select-dropdown-slide-up-enter,
.rc-tree-select-dropdown-slide-up-appear {
-webkit-animation-duration: .3s;
animation-duration: .3s;
-webkit-animation-fill-mode: both;
animation-fill-mode: both;
-webkit-transform-origin: 0 0;
transform-origin: 0 0;
opacity: 0;
-webkit-animation-timing-function: cubic-bezier(0.08, 0.82, 0.17, 1);
animation-timing-function: cubic-bezier(0.08, 0.82, 0.17, 1);
-webkit-animation-play-state: paused;
animation-play-state: paused;
}
.rc-tree-select-dropdown-slide-up-leave {
-webkit-animation-duration: .3s;
animation-duration: .3s;
-webkit-animation-fill-mode: both;
animation-fill-mode: both;
-webkit-transform-origin: 0 0;
transform-origin: 0 0;
opacity: 1;
-webkit-animation-timing-function: cubic-bezier(0.6, 0.04, 0.98, 0.34);
animation-timing-function: cubic-bezier(0.6, 0.04, 0.98, 0.34);
-webkit-animation-play-state: paused;
animation-play-state: paused;
}
.rc-tree-select-dropdown-slide-up-enter.rc-tree-select-dropdown-slide-up-enter-active.rc-tree-select-dropdown-placement-bottomLeft,
.rc-tree-select-dropdown-slide-up-appear.rc-tree-select-dropdown-slide-up-appear-active.rc-tree-select-dropdown-placement-bottomLeft {
-webkit-animation-name: rcSelectDropdownSlideUpIn;
animation-name: rcSelectDropdownSlideUpIn;
-webkit-animation-play-state: running;
animation-play-state: running;
}
.rc-tree-select-dropdown-slide-up-leave.rc-tree-select-dropdown-slide-up-leave-active.rc-tree-select-dropdown-placement-bottomLeft {
-webkit-animation-name: rcSelectDropdownSlideUpOut;
animation-name: rcSelectDropdownSlideUpOut;
-webkit-animation-play-state: running;
animation-play-state: running;
}
.rc-tree-select-dropdown-slide-up-enter.rc-tree-select-dropdown-slide-up-enter-active.rc-tree-select-dropdown-placement-topLeft,
.rc-tree-select-dropdown-slide-up-appear.rc-tree-select-dropdown-slide-up-appear-active.rc-tree-select-dropdown-placement-topLeft {
-webkit-animation-name: rcSelectDropdownSlideDownIn;
animation-name: rcSelectDropdownSlideDownIn;
-webkit-animation-play-state: running;
animation-play-state: running;
}
.rc-tree-select-dropdown-slide-up-leave.rc-tree-select-dropdown-slide-up-leave-active.rc-tree-select-dropdown-placement-topLeft {
-webkit-animation-name: rcSelectDropdownSlideDownOut;
animation-name: rcSelectDropdownSlideDownOut;
-webkit-animation-play-state: running;
animation-play-state: running;
}
@-webkit-keyframes rcSelectDropdownSlideUpIn {
0% {
opacity: 0;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
100% {
opacity: 1;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
}
@keyframes rcSelectDropdownSlideUpIn {
0% {
opacity: 0;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
100% {
opacity: 1;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
}
@-webkit-keyframes rcSelectDropdownSlideUpOut {
0% {
opacity: 1;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
100% {
opacity: 0;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
}
@keyframes rcSelectDropdownSlideUpOut {
0% {
opacity: 1;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
100% {
opacity: 0;
-webkit-transform-origin: 0% 0%;
transform-origin: 0% 0%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
}
@-webkit-keyframes rcSelectDropdownSlideDownIn {
0% {
opacity: 0;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
100% {
opacity: 1;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
}
@keyframes rcSelectDropdownSlideDownIn {
0% {
opacity: 0;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
100% {
opacity: 1;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
}
@-webkit-keyframes rcSelectDropdownSlideDownOut {
0% {
opacity: 1;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
100% {
opacity: 0;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
}
@keyframes rcSelectDropdownSlideDownOut {
0% {
opacity: 1;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(1);
transform: scaleY(1);
}
100% {
opacity: 0;
-webkit-transform-origin: 0% 100%;
transform-origin: 0% 100%;
-webkit-transform: scaleY(0);
transform: scaleY(0);
}
}
.rc-tree-select-dropdown-search {
display: block;
padding: 4px;
}
.rc-tree-select-dropdown-search .rc-tree-select-search__field__wrap {
width: 100%;
}
.rc-tree-select-dropdown-search .rc-tree-select-search__field__placeholder {
top: 4px;
}
.rc-tree-select-dropdown-search .rc-tree-select-search__field {
padding: 4px;
width: 100%;
box-sizing: border-box;
border: 1px solid #d9d9d9;
border-radius: 4px;
outline: none;
}
.rc-tree-select-dropdown-search.rc-tree-select-search--hide {
display: none;
}
.rc-tree-select-open .rc-tree-select-arrow b {
border-color: transparent transparent #888 transparent;
border-width: 0 4px 5px 4px;
}
.rc-tree-select-not-found {
display: inline-block;
padding: 8px;
}
| code |
Raj Kundra:సోషల్ మీడియాకు దూరంగా శిల్పా శెట్టి భర్త..! అశ్లీల చిత్రాల రాకెట్ వ్యవహారంలో శిల్పాశెట్టి భర్త వ్యాపారవేత్త రాజ్ కుంద్రా అరెస్టయిన సంగతి తెలిసిందే. కొద్ది రోజుల క్రితం ఆయన బెయిల్పై విడుదలయ్యాడు. అయితే జైలులో ఉన్న సమయంలో రాజ్కుంద్రాపై చాలా మంది దారుణమైన కామెంట్స్ చేశారు. సోషల్ మీడియాలో అయితే లెక్కే లేదు. ఈ వివాదం నుండి రాజ్కుంద్రా ఇంకా బయటపడలేదు.ఇప్పటికీ ఆయనపై విమర్శల పర్వం కొనసాగుతూనే ఉంది. అయితే సోషల్ మీడియాలో యాక్టివ్గా ఉండే రాజ్ కుంద్రా తన రెండు సోషల్ మీడియా ఖాతాలను తొలగించడం చర్చనీయాంశమైంది. రాజ్ కుంద్రా బెయిల్ పై విడుదలయ్యాక.. ఆయనతో ఎంతో సంతోషంగా ఉన్న ఫోటోలు వీడియోలను శిల్పాశెట్టి షేర్ చేశారు. శిల్పాశెట్టి ఎట్టకేలకు జనంలోకి వెళుతున్నారు. తన వృత్తి జీవితంలో కూడా తిరిగి బిజీ కానున్నారు. కాని రాజ్ కుంద్రా ఎక్కడా కనిపించకపోవడం చర్చనీయాంశంగా మారింది. సాలువాల వ్యాపారి నీలిచిత్రాల వ్యాపారిగా మారిన వైనంపై చర్చ అప్పట్లో దేశంలో ప్రకంపనాలు రేపింది. బాలీవుడ్ నిర్మాత .. బిజినెస్ మేన్ రాజ్ కుంద్రా అశ్లీల వీడియోల వ్యవహారంపై పలువురు నటీమణులు లైంగిక వేధింపుల ఆరోపణలు చేసారు. నటి షెర్లిన్ చోప్రా అతడిపై లైంగిక వేధింపుల ఆరోపణలు చేయడం అప్పట్లో పెద్ద సేన్సేషన్ అయింది. | telegu |
ಕುತಂತ್ರ ಬುದ್ದಿಯನ್ನು ಮತ್ತೆ ತೋರಿಸಿದ ಚೀನಾ ಎಷ್ಟೇ ಪಾಠ ಕಲಿಸಿದರೂ ಯಾಕೋ ಚೀನಾ ಬುದ್ದಿ ಕಲಿಯುವಂತೆ ಕಾಣುತ್ತಿಲ್ಲ. ಇದೀಗ ಮತ್ತೆ ತಮ್ಮ ಕ್ಯಾತೆ ತೆಗೆಯೋದಿಕ್ಕೆ ರೆಡಿ ಆದಂತೆ ಕಾಣುತ್ತಿದೆ. ಗಡಿಭಾಗದಿಂದ ಎರಡೂ ಕಡೆಯ ಸೈನಿಕರು ನಿರ್ಗಮಿಸಬೇಕೆಂದು ಮಾತುಕತೆಯಾಗಿದ್ದರೂ ಚೀನಿ ಸೈನಿಕರು ಇನ್ನು ಗಡಿ ಸಮೀಪವೇ ಇದ್ದಾರೆ ಎನ್ನಲಾಗಿದೆ. ಹೌದು, ಲಡಾಖ್ನ ಪೂರ್ವಭಾಗದ ಗಡಿ ಪ್ರದೇಶದ ಸಮೀಪ 40 ಸಾವಿರ ಚೀನಿ ಸೈನಿಕರು ಇದ್ದಾರೆ ಎಂದು ವರದಿಗಳಾಗಿವೆ. ಅಲ್ಲದೆ ಈ ಚೀನಿ ಸೈನಿಕರ ಬಳಿ ಏರ್ ಡಿಫೆನ್ಸ್ ಸಿಸ್ಟಂಗಳು, ದೂರ ಶ್ರೇಣಿಯ ಆರ್ಟಿಲರರಿ ಸೇರಿದಂತೆ ಹಲವು ಶಸ್ತ್ರಾಸ್ರಗಳು ಇವೆ ಎನ್ನಲಾಗಿದೆ. ಈ ಚೀನಿ ಸೈನಿಕರು ಫಿಂಗರ್ 5 ಪ್ರದೇಶದ ವ್ಯಾಪ್ತಿಯಲ್ಲಿರುವ ಹಾಟ್ ಸ್ಪ್ರಿಂಗ್ಸ್ ಮತ್ತು ಗೋಗ್ರಾ ಪೋಸ್ಟ್ ಏರಿಯಾದಲ್ಲಿ ಕಟ್ಟಡ ನಿರ್ಮಾಣ ಮಾಡಿಕೊಂಡು ಇದ್ದಾರೆ ಎನ್ನಲಾಗುತ್ತಿದೆ. ನಾವು ಇಲ್ಲಿಂದ ಹೋದರೆ ಭಾರತೀಯರು ಅತಿಕ್ರಮಿಸುತ್ತಾರೆ ಎಂಬ ನೆಪವೊಡ್ಡಿ ಅಲ್ಲಿ ಇದ್ದಾರೆ ಎನ್ನಲಾಗುತ್ತಿದೆ. | kannad |
నిషేధిత ఆస్తుల జాబితాలో 20 లక్షల ఎకరాలు.. ఇదేందయ్యా కేసీయారూ! తెలంగాణలో రెవిన్యూ సంస్కరణల గురించి గంభీర వచనాలు వల్లించిన కేసీఆర్.. ఆ మాటలు చెప్పి రెండేళ్లు కావస్తున్నా రాష్ట్ర ప్రజల సమస్యలకు పరిష్కారం మాత్రం చూపించలేకపోయారు. అనేక దఫాలుగా ఎన్నో గంటలపాటు సమావేశాలు జరిపి తయారు చేసిన మార్గదర్శకాల మేరకు అధికారులు పని చేయలేకపోతున్నారా.. లేక మార్గదర్శకాలు, పని విభజనే అశాస్త్రీయంగా ఉందా.. అదీగాక అధికారులు తమ పాత పద్ధతిలోనే లంచాల సంస్కృతిని మరింత పెంచి పోషిస్తూ భూముల లావాదేవీల్లో కొర్రీలు వేస్తున్నారా అన్న విమర్శలకు ఇప్పుడు బలం పెరిగింది. ఇందులో అధికారుల లోపం ఉందా.. ప్రభుత్వం చేతగానితనం ఉందా అనేది కాసేపు పక్కనపెడితే.. ఇప్పటికీ 20 లక్షల ఎకరాల ప్రైవేట్ పట్టా ల్యాండ్ నిషేధిత ఆస్తుల జాబితాలో ఉండడమే అందుకు ఓ నిదర్శనంగా చెబుతున్నారు విపక్ష పార్టీల నేతలు. రాష్ట్ర ప్రభుత్వం రూపొందించిన నిషేధిత ఆస్తుల జాబితా రైతుల పాలిట శాపంగా మారింది. ప్రభుత్వ, దేవాదాయ, వక్ఫ్, సీలింగ్, అసైన్డ్ ల్యాండ్స్ ఉండాల్సిన ఈ లిస్టులో లక్షలాది మంది అసలైన పట్టాదారుల సర్వే నెంబర్లు నమోదయ్యాయి. అధికారులు చేసిన తప్పులు.. ప్రభుత్వం పట్టించుకోకపోవటంతో దాదాపు 20 లక్షల ఎకరాల పట్టా ల్యాండ్స్ నిషేధిత ఆస్తుల చిట్టాలో చిక్కుకున్నాయి. దీంతో అసలు సిసలైన యజమానులు తమ భూములను అమ్ముకోలేక.. కుటుంబీకులకు మ్యుటేషన్ చేసుకోలేక తిప్పలు పడుతున్నారు. కొన్ని జిల్లాల్లో ఫ్రీడమ్ ఫైటర్లు, మాజీ సైనికులకు ఇచ్చిన భూములు ఈ జాబితాలో ఉండటం రెవిన్యూ రికార్డుల్లోని తప్పులను వేలెత్తి చూపుతోంది. తమ దగ్గర పట్టాదారు పాసు పుస్తకాలున్నాయని.. తమ భూములను నిషేధిత జాబితా నుంచి తొలగించాలని బాధితులు ఏళ్లకేళ్లుగా ఆఫీసుల చుట్టూ తిరుగుతూనే ఉన్నారు. జిల్లా అధికారుల నుంచి ఎన్వోసీ తెచ్చుకోవాలని.. అప్పుడే ఆ జాబితా నుంచి భూములు తొలగిస్తామని రెవిన్యూ సిబ్బంది ఉచిత సలహాలిచ్చి చేతులు దులుపుకుంటున్నారు. అధికారులు చేసిన తప్పులకు తాము బలవుతున్నామని, ఎన్వోసీ తెచ్చుకునేందుకు లంచాల రూపంలో భారీ మూల్యం చెల్లించుకోవాల్సి వస్తోందని బాధితులు ఆందోళన చెందుతున్నారు. గతంలో హైదరాబాద్ ను ఆనుకునే ఉన్న ఓ జిల్లాలో అడిషనల్ కలెక్టర్ ఏసీబీకి చిక్కింది కూడా ఇలాంటి కేసులోనే కావటం గమనార్హం. అంతేకాదు.. ఇరిగేషన్ ప్రాజెక్టులకు ఇచ్చిన భూములపైనా క్లారిటీ లేకుండా నోషనల్ ఖాతాలకే పరిమితం చేశారు. దీనివల్ల లబ్ధిదారులకు నష్టపరిహారం సైతం ఇంకా అందకుండా పోతోందన్న విమర్శలు వెల్లువెత్తుతున్నాయి. ఫ్రీడం ఫైటర్లు, మాజీ సైనికులకు ఇచ్చిన భూములు కూడా ప్రొహిబిటెడ్ జాబితాలోకి వెళ్లిపోయి అభివృద్ధి చేసుకోవాలన్నా లేక అవసరం మేరకు అమ్ముకోవాలన్నా, మరేదైనా ఇతర అవసరాలకు పనికిరాకుండా పోతున్నాయి. దీంతో పిల్లల చదువులైనా, పెళ్లీడుకొచ్చిన పిల్లలకైనా ఉపయోగపడకుండా పోయాయి. అసలు ఇలాంటి భూములకు రిజిస్ట్రేషన్ల శాఖ సింపుల్ గా రెడ్ మార్క్ పెట్టి కూర్చోవడంతో ఒక్క అడుగు కూడా ముందుకు పడడం లేదన్న విమర్శలు వినిపిస్తున్నాయి. అందుకే నిషేధిత జాబితా నుంచి తమ భూములు తీసేయాలని ధరణి పోర్టల్ ద్వారా ఇప్పటికే 60 వేల మంది అప్లికేషన్లు పెట్టుకున్నారు. వీరంతా ఎన్వోసీ కోసం రెవిన్యూ కార్యాలయాల చుట్టూ తిరుగుతున్నారు. అటు అధికారులు భూముల విలువను బట్టి ఎన్వోసీ కోసం లంచాలు డిమాండ్ చేస్తున్నారు. రెవిన్యూ అధికారుల మీద బాధిత ప్రజలు దాడులు చేస్తున్నా లంచావతారులకు మాత్రం అడ్డుకట్ట పడలేదు. ఇంత జరుగుతున్నా ప్రభుత్వం నుంచి ఇప్పటికైతే పరిష్కారం దక్కలేదన్న విమర్శలు వినిపిస్తున్నాయి. మరి హుజూరాబాద్ ఎన్నిక సందర్భంగానైనా ఈ ప్రజోపయోగ కార్యక్రమాన్ని పట్టాలకెక్కిస్తారా అంటున్నారు సామాన్య జనం. | telegu |
रोडवेज कर्मचारियों का मांगों को लेकर धरना प्रदर्शन रोडवेज कर्मचारियों ने मांगों को लेकर डिपो कार्यालय पर चल रहा धरना प्रदर्शन शुक्रवार को दूसरे दिन भी जारी रहा। कर्मचारी संगठन ने दो टूक कहा कि जब तक उन्हें दो माह का वेतन जारी नहीं किया जाता। तब तक वह अपना विरोध जारी रखेंगे।रोडवेज कर्मचारि संयुक्त परिषद के महामंत्री दिनेश पंत ने कहा कि कर्मचारियों की समस्याओं को लेकर निगम केवल वार्ताएं करता है। लेकिन विभागीय स्तर पर समस्याएं फिर भी हल नहीं हो पाती। उन्होंने बताया कि समस्त क्षेत्रों में कर्मचारी अपनी मांगों को लेकर एक घंटे धरना प्रदर्शन कर रहे हैं। उन्होंने कहा कि विशेष श्रेणी कर्मचारियों को डीए और एरियर का भुगतान करने, नियमित कर्मचारियों के वेतन से कटौती के आदेश तत्काल निरस्त करने, एचआरए, डीए को लेकर आदेश जारी करने समेत अन्य मांगें पूरी नहीं की गई तो कर्मचारी आंदोलन और तेज करेंगे। For Hindustan : हिन्दुस्तान ईसमाचार पत्र के लिए क्लिक करें epaper.livehindustan.com | hindi |
ദുര്ഗാ പൂജയ്ക്കിടെ ബംഗ്ലാദേശിലെ ക്ഷേത്രങ്ങള്ക്കെതിരായ അക്രമം: കര്ശന നടപടി സ്വീകരിക്കാന് നിര്ദ്ദേശം നല്കി പ്രധാനമന്ത്രി ഷേഖ് ഹസീന ധാക്കയില് പ്രതിഷേധിച്ച് വിവിധ സംഘടനകള് ധാക്ക: ബംഗ്ലാദേശില് ദുര്ഗ പൂജയ്ക്കിടെ ക്ഷേത്രങ്ങള് അക്രമിച്ചവര്ക്കെതിരെ കര്ശന നടപടി സ്വീകരിക്കാന് നിര്ദ്ദേശം നല്കി പ്രധാനമന്ത്രി ഷേഖ് ഹസീന. ചൊവ്വാഴ്ച ചേര്ന്ന മന്ത്രിസഭാ യോഗത്തിലാണ് അക്രമികള്ക്കെതിരെ ഉടന് നടപടി സ്വീകരിക്കാന് ആഭ്യന്തരമന്ത്രി അസദുസ്സമാന് ഖാന് നിര്ദ്ദേശം നല്കിയത്. ഇത്തരം സംഭവങ്ങള് ആവര്ത്തിക്കാതിരിക്കാന് നടപടി സ്വീകരിക്കണമെന്നും അവര് മുന്നറിയിപ്പ് നല്കി. ബംഗ്ലാദേശ് കാബിനറ്റ് സെക്രട്ടറി ഖണ്ഡ്ക്കര് അന്വാറുല് ഇസ്ലാമിനെ ഉദ്ധരിച്ച് ധാക്ക ട്രിബ്യൂണ് പത്രമാണ് ഈ വാര്ത്ത റിപ്പോര്ട്ട് ചെയ്യുന്നത്. ബംഗ്ലാദേശില് ദുര്ഗാ പൂജയ്ക്കിടെ നടന്ന ആക്രമണങ്ങള്ക്കും തുടര്ന്നുണ്ടായ അക്രമ സംഭവങ്ങളിലും പ്രതിഷേധിച്ച് വിവിധ സംഘടനകള് സമരം ശക്തമാക്കിയിരുന്നു. വിവിധ ഹിന്ദു സംഘടനകളും വിദ്യാര്ത്ഥി സംഘടനകളും മറ്റ് സംഘങ്ങളുമാണ് രാജ്യ തലസ്ഥാനമായ ധാക്കയില് പ്രതിഷേധം ശക്തമാക്കിയത്. അക്രമങ്ങള് അവസാനിപ്പിക്കണമെന്നും ഇതിന് പിന്നിലുള്ളവര്ക്കെതിരെ നടപടിയെടുക്കണമെന്നുമാണ് പ്രതിഷേധക്കാരുടെ ആവശ്യം. സംഘര്ഷത്തില് ആറുപേര് കൊല്ലപ്പെട്ടതായാണ് ഇതുവരെ സ്ഥിരീകരിച്ചിട്ടുള്ളത്. കഴിഞ്ഞ പത്തു ദിവസങ്ങള്ക്കുള്ളില് മാത്രം 150 ലധികം ദുര്ഗ പൂജ പന്തലുകള് തകര്ക്കപ്പെട്ടു. 362ല് അധികം വിഗ്രഹങ്ങള് തകര്ത്തു. ആയിരക്കണക്കിന് ഹിന്ദുക്കളുടെ വീടുകളും കടകളും ആക്രമിക്കപ്പെട്ടു. ഇതില് ആയിരത്തിലധികം ഹിന്ദുക്കള്ക്ക് പരിക്കേറ്റു. ഇതുവരെ 10 ഹിന്ദുക്കള് കൊല്ലപ്പെട്ടതായാണ് റിപ്പോര്ട്ട്. നിരവധി ഹിന്ദു സ്ത്രീകള് ക്രൂരമായി കൂട്ടബലാത്സംഗത്തിന് ഇരയായി. ചന്ദ്പൂരിലെ ഹാജി ഗഞ്ചില്, ഒരു സ്ത്രീയും മകളും അവളുടെ സഹോദരിയുടെ മകളും ക്രൂരമായി കൂട്ടബലാത്സംഗം ചെയ്യപ്പെട്ടു. നിരപരാധിയായ 10 വയസ്സുള്ള ഒരു പെണ്കുട്ടി അവിടെ കൊല്ലപ്പെട്ടു. മൂന്ന് ഇസ്കോണ് ക്ഷേത്രങ്ങള്, രാമകൃഷ്ണ മിഷന്റെ ആശ്രമങ്ങള്, രാം താക്കൂര് ആശ്രമം എന്നിവയുള്പ്പെടെ അമ്ബതിലധികം ക്ഷേത്രങ്ങള് നശിപ്പിക്കപ്പെട്ടു. ഇസ്കോണിലെ രണ്ട് സംന്യാസിമാരും ചൗമോഹിനി ക്ഷേത്രത്തിലെ പുരോഹിതരും ക്രൂരമായി കൊല്ലപ്പെട്ടു. മറ്റൊരു പുരോഹിതന്റെ മൃതദേഹം ഇസ്കോണ് ക്ഷേത്രത്തിലെ കുളത്തില് നിന്ന് കണ്ടെത്തുകയും ചെയ്തു. ബംഗ്ലാദേശ് ഹിന്ദു, ബുദ്ധിസ്റ്റ്, ക്രിസ്ത്യന് യൂണിറ്റി കൗണ്സില് ഈ മാസം 23 മുതല് പൂജാ ദിനത്തിലെ അക്രമങ്ങളില് പ്രതിഷേധിച്ച് നിരാഹാരസമരം ആരംഭിച്ചിട്ടുണ്ട്. ഒക്ടോബര് 15നാണ് ബംഗ്ലാദേശില് അക്രമസംഭവങ്ങള് ആരംഭിച്ചത്. പിന്നാലെ 22 ജല്ലകളില് അര്ധസൈനിക സേനയെ വിന്യസിച്ചിരുന്നു. Stories you may Like | malyali |
کراچی اردوپوائنٹ اخبا تازہ ترین11 مارچ 2008 اوپن کر نسی ما کیٹ میں کاروباری ہفتے کے دوسرے روزمنگل کو روپے کی نسبت ڈالراوریوروکی قدر میں اضافہ جبکہ برطانوی پانڈ کی قدر میں کمی ریکارڈ کی گئی فاریکس ایسوسی ایشن کی جانب سے جاری کردی رپورٹ کے مطابق اوپن کرنسی مارکیٹ میں ڈالر کی قیمت میں10پیسے کا اضافہ ریکارڈ کیا گیا جس کے باعث ڈالر کی قیمت خرید 6275روپے سے بڑھ کر6285روپے اور قیمت فروخت 6285روپے سے بڑھ کر6295روپے ہوگئی یورو کی قیمت 5پیسے کا اضافہ جبکہ برطانوی پانڈکی قیمت میں50پیسے کی کمی ریکارڈ کی گئی جس سے بالترتیب یورو کی قیمت خرید 9600روپے سے بڑھ کر9605روپے اور قیمت فروخت 9610روپے سے بڑھ کر9615روپے جبکہ برطانوی پانڈ کی قیمت خرید 12600 روپے سے گھٹ کر12550روپے اور قیمت فروخت 12610 روپے سے گھٹ کر 12560روپے ہوگئی علاوہ ازیں منگل کو انٹر مارکیٹ میں ڈالر کی قیمت میں5پیسے کی کمی ریکارڈ کی گئی جسکے باعث انٹر مارکیٹ میں ڈالر کی قیمت خرید کر 6280 روپے سے گھٹ کر6275روپے اورقیمت فروخت 6282 روپے سے گھٹ کر6277روپے ہوگئی | urdu |
Subsets and Splits