Howdy tech enthusiasts! 🤓 Today, we're taking a deep dive into the world of Ngrok and SSH tunneling. I'll be your guide through this process and by the end of it, you'll be a master at setting up Ngrok to expose your SSH service on port 22 to the internet. Plus, I'll show you how to stop the Ngrok process when you're done using it. Sound good? Let's get started!

Getting Started with Ngrok

1. Download the Ngrok binary from the official website:

wget https://bin.equinox.io/c/bNyj1mQVY4c/ngrok-v3-stable-linux-amd64.tgz

2. Unpack the downloaded file using the tar command:

tar --extract --verbose --file ngrok-v3-stable-linux-amd64.tgz

3. Move the Ngrok binary to a directory in your system's PATH:

mv ngrok /usr/local/bin

Setting Up Your Ngrok Account

3. Get your Ngrok authtoken from your account dashboard on the Ngrok website.

4. Add the authtoken to the configuration file to authenticate with the Ngrok service:

ngrok config add-authtoken Your_Authtoken_Here

Running Ngrok

5. Run Ngrok to expose your SSH service to the internet (replace 22 with your SSH service port number if different):

ngrok tcp 22

Or you can run Ngrok in the background and keep it running even after closing the terminal using the nohup command and send the process to the background using &:

nohup ngrok tcp 22 --log=/path/to/your/logfile.log &

Monitoring the Ngrok Log

6. You can monitor the Ngrok log to see the status of the tunnel:

tail --follow=name /path/to/your/logfile.log

At the end of the log output, you should see a line that looks like this:

t=2023-05-10T05:52:42+0000 lvl=info msg="started tunnel" obj=tunnels name=command_line addr=//localhost:22 url=tcp://0.tcp.jp.ngrok.io:10465

The URL at the end of this line is the public URL that you can use to access your SSH service from the internet.

Wrapping Up Your Ngrok Session

Once you're done with Ngrok, you can stop the process by finding its process ID (PID) and then using the kill command:

7. Find the PID of the Ngrok process using the ps aux | grep ngrok command:

ps aux | grep --color=auto ngrok

8. Once you have the PID, use the kill command to stop the Ngrok process:

kill Ngrok_PID

Don't forget to replace Ngrok_PID with the actual process ID of the Ngrok process.

And that's a wrap, folks! You've successfully set up Ngrok for SSH tunneling on your Linux system. Congratulations! You can now access your SSH service from anywhere with an internet connection.

Thanks for tuning in and happy hacking! 😎

As a dedicated software engineer and a proud member of the PLASS lab, I had the unique opportunity to contribute to a cutting-edge project entitled "Diaphragm Function Evaluation through Chest CT Image in COPD Patients." This project, a collaboration with Prof. Jinkyeong Park from the Department of Pulmonary at Kyung Hee University Hospital, was generously supported by the Ministry of Science and ICT (MSIT) of the Government of the Republic of Korea. Our primary objective was to develop a precise and practical method for evaluating diaphragm function in COPD patients using chest CT images.

Project Approach

As the architect of the experiment, I was responsible for designing and implementing the code. Our approach comprised several stages, utilizing image processing algorithms, computational geometry algorithms, and surface fitting algorithms to generate simulated diaphragm surfaces. We employed Python, C++, MATLAB, NumPy, Pandas, CGAL, OpenCV, Open3D, Plotly, and other libraries in our implementation.

The following steps were undertaken during the project:

1. Reading CT slices from DICOM images and generating a 3D visualization of the lungs.
2. Implementing a Python-based denoising algorithm to minimize image noise.
3. Extracting the lung bottom from the 3D visualization and converting the 3D point cloud into a 3D polygon mesh.
4. Creating numerous polylines using CGAL and C++ and intersecting these polylines with the 3D polygon mesh of pulmonary substructure.
5. Recording the coordinates of polyline intersections with the 3D polygon mesh.
6. Constructing a non-border diaphragm surface using MATLAB's gridfit surface fitting function.
7. Segmenting the final diaphragm surface using the pulmonary substructure mask, extracted via a collision algorithm-based method.
8. Designing a correction technique to obtain the area closest to the actual situation, considering that the simulated diaphragm and the real diaphragm's end are not connected.

Results and Achievements

Our innovative method demonstrated exceptional accuracy and feasibility in evaluating diaphragm function in COPD patients. We submitted a paper entitled "Motility Analysis of Diaphragm in Patients with Chronic Pulmonary Lung Disease Based on Computed Tomography Technique" to IEEE Access, where I serve as the lead author. The paper is currently under review (manuscript number Access-2023-01370).

IEEE_Access_Paper_Hao_Yu-v9.1.0.pdf

Google Docs

This project yielded a non-invasive and accurate method for assessing diaphragm function in COPD patients, with the potential to enhance diagnostic and treatment strategies. Furthermore, our project provided an unparalleled learning experience, as our diverse team consisted of members from three different countries.

Conclusion

In summary, our proposed method for evaluating diaphragm function in COPD patients using chest CT image analysis showcased outstanding accuracy and practicality. We made use of various algorithms and libraries throughout the implementation process, ultimately producing a non-invasive method for assessing diaphragm function in COPD patients. This project also fostered a unique learning environment, as our team collaborated with specialists from various countries.

As a software engineer, I had the opportunity to lead the development of just-LINK mobile, an educational video conferencing app using React Native and TypeScript. Our team, comprising members from four different countries, employed TypeScript to catch errors at compile-time and reduce data redundancy in REST API and WebSocket.

Team Collaboration and Leadership

As the lead developer, I ensured that our team delivered high-quality software on time. I developed my leadership skills and learned to communicate effectively with a diverse team. We followed the agile development model, using Jira for task management and Slack for communication. Unito.io helped us connect Jira, Github, and Slack, making task synchronization easier. Our team culture emphasized transparency, mutual respect, and effective feedback, helping us work efficiently and deliver results.

Tech Stack

We used a combination of React Native, React Native WebRTC, React Native Incall Manager, React Native Async Storage, React Native Clipboard, React Native Picker, React Native Modal, React Native Permissions, React Native SVG, Android SDK, and libraries like React, React Router, React Navigation, Redux, Redux Persist, Redux Thunk, Reselect, Immer, and Lodash for the just-LINK mobile client. This tech stack helped us create a user-friendly, responsive, and feature-rich app. React Native framework played a significant role in delivering a seamless and native-like experience across both iOS and Android platforms. React Native WebRTC helped us implement real-time video conferencing, delivering a high-quality and reliable video conferencing experience to our users.

Features and Contributions

During the development of the just-LINK mobile app, I played a crucial role in several areas, including:

• Designing and developing a comprehensive cross-platform app architecture, ensuring optimal functional UI for both iOS and Android platforms.
• Implementing efficient Redux state management and designing the meeting room screen layout.
• Developing multiple REST API requests, including a feature to send the local device state to other users and building a swipe meeting room UI allowing users to swipe and touch videos of participants, bringing them to the center of the screen.
• Employing the AES algorithm using crypto-js to encrypt usernames and passwords, ensuring enhanced security.
• Conducting iOS app testing using TestFlight and successfully submitting the app to the App Store for distribution.
• Reviewing all pull requests while suggesting necessary changes and taking charge of 75% of the app development.
• Implementing screen share functionality and creating the UI for the landscape mode of the app.
• Creating various screens, such as AuthScreen, ChatScreen, JoinLinkScreen, LectureScreen, LoginScreen, MeetingScreen, RoomInfoScreen, and UserListScreen, to provide users with an exceptional experience.
• Developing various features, including the ask-to-join feature for guest users and the ability to change usernames.
• Creating detailed setup and contribution documentation to ensure project transparency and scalability.
• Internationalizing the app for four different languages, enhancing its global appeal.

Learning Experience

Developing the just-LINK mobile client was a remarkable learning experience. Collaborating with a multicultural team taught me the importance of effective communication and feedback. We used an agile development model, refining our features based on user feedback, delivering software in increments. Working on this project allowed me to hone my skills in TypeScript, React Native, and mobile app development.

Conclusion

The development of just-LINK mobile was an exciting and challenging project that allowed me to develop my skills as a software engineer and as a leader. Our team developed a system that empowers educators to deliver an interactive and engaging learning experience to their students remotely. I'm proud to be part of this team and look forward to continuing to work on this project and delivering a high-quality product that will benefit the education industry.

As a software engineer, I had the opportunity to work on the development of just-LINK, a WebRTC-based educational video conferencing software. The project was a collaboration between our PLASS lab team and Unique UX Co., Ltd., with the aim of developing a system that would seamlessly integrate with their learning management system, enabling educators to deliver an interactive and engaging learning experience to their students remotely.

Role and Contributions

My role as a software engineer involved developing 40% of the frontend React web application and 20% of the backend Node.js and MySQL development. I used various tools and technologies such as TypeScript, JavaScript, ES6, Node.js, ExpressJS, MySQL, Redis, Nginx, CloudFlare, Webpack, Babel, Sass, CSS3, HTML5, React, Redux, Redux-Thunk, Redux Persist Utilities, reselect, Socket.IO, WebRTC, Lodash, Moment.js, Axios, Passport, Postman, Git, GitHub, Vim, Visual Studio Code, WebStorm, Xcode, npm, Yarn, nodemon, pm2, and TURN server to accomplish my responsibilities.

Features Implemented

The following are some of the features that I implemented in just-LINK:

Server Management:

• Configured Nginx configuration files to ensure seamless server operation.
• Installed and established a TURN server for reliable and secure communication.

General:

• Developed efficient and concise code for various HTTP requests utilizing Axios.
• Implemented multiple REST API endpoints using Express.js.
• Utilized multiple socket.io to incorporate multiple websocket emitters and listeners for real-time communication.
• Designed and modified database tables to store data using node-mysql2, thereby achieving efficient data management.
• Created state management instances using Redux and related tools such as Redux-Thunk.

Meeting Room Component Development:

• Integrated React-Toastify to facilitate in-app notifications of user entry/exit for an enhanced user experience.
• Developed a feature to enable instructors to approve/deny student entry to the meeting room for better control.
• Constructed a dropdown menu within the video component to ensure easy access to settings.
• Implemented a feature to enable users to update their displayed names within the meeting room.

Landing Page Component Development:

• Designed the user interface for the landing page component based on the provided Zeplin design to create a cohesive and attractive UI.
• Developed a sound meter component to visually represent microphone sound levels on the landing page for a better user experience.
• Created a camera and microphone selector component to manage audio/visual input options on the landing page for improved functionality.
• Designed a setting to allow instructors to preset student camera and microphone settings in the meeting room settings page for better customization.

User List Component Development:

• Developed the user interface design for the user list component based on the provided Zeplin design.
• Incorporated a sliding transition effect when switching between user list views with React Transition Group to create a smooth user experience.
• Differentiated user avatars based on host permissions to provide a clear indication of host status.
• Designed the user list to pin the current user and added functionality for other users to pin the list for better organization.

Chat Component Development:

• Implemented the user interface design for the chat component based on the provided Zeplin design.
• Designed a feature to cancel downloads to enhance usability.
• Incorporated direct/private messaging functionality for better communication.
• Integrated a feature to download files from a chat window for a better user experience.
• Improved the user interface of image and file transfers for better visual display.

Collaboration and Communication

Working on just-LINK provided me with the opportunity to collaborate with multicultural teams, as our team members came from 4 different countries. Effective communication and feedback were crucial for the project's success. We learned how to communicate effectively, provide feedback regularly, and work toward a common goal. Through this experience, I developed my communication skills and learned how to work in a team effectively.

Agile Software Development

Just-LINK was developed using an agile software development approach, allowing us to deliver the software in increments and continuously refine the features based on user feedback. Working with an agile team taught me how to prioritize tasks, break them down into smaller, more manageable components, and adapt to changes quickly.

Conclusion

In conclusion, developing just-LINK was an incredible learning experience that allowed me to gain valuable experience in software development, collaboration, communication, and agile software development. The skills I have acquired during this project will be beneficial in my future endeavors. I am proud to have been part of the team that developed just-LINK, a system that empowers educators to deliver an interactive and engaging learning experience to their students remotely.

Debugging code is an essential skill for any programmer. It allows you to identify and fix errors in your code quickly and efficiently. PyCharm comes with a powerful debugger that can make the debugging process much easier. In this blog post, we will explore the different debugging features available in PyCharm and how to use them effectively.

Setting Breakpoints

Breakpoints are markers in your code that tell the debugger to pause the program's execution at a specific line of code. You can set a breakpoint in PyCharm by clicking on the left margin of the code editor. A red dot will appear, indicating that the debugger will pause the program's execution at that line.

# Example of setting a breakpoint in PyCharm
def main():
    x = 1
    y = 2
    z = x + y  # Set breakpoint on this line
    print(z)

if __name__ == "__main__":
    main()

Stepping Through Your Code

Once you have set a breakpoint, you can use the Step Over button to execute the next line of code after the breakpoint. This is useful when you want to step through your code line by line and identify the source of a problem. To use Step Over, click on the Step Over button, which looks like a blue right arrow.

# Example of using the Step Over button in PyCharm
def main():
    x = 1
    y = 2
    z = x + y  # Set breakpoint on this line
    print(z)  # Use Step Over to execute this line

if __name__ == "__main__":
    main()

The Step Into button allows you to step into a function call and inspect its implementation. If you only want to step into your code and not external libraries, you can use the Step Into My Code button.

# Example of using the Step Into button in PyCharm
def add(x, y):
    return x + y

def main():
    x = 1
    y = 2
    z = add(x, y)  # Set breakpoint on this line
    print(z)  # Use Step Into to inspect the add function

if __name__ == "__main__":
    main()

The Step Out button allows you to move out of the current function and return to the caller function. This is useful when you want to quickly move to the next function call without stepping through the entire function's implementation.

# Example of using the Step Out button in PyCharm
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

def main():
    x = 1
    y = 2
    z = add(x, y)  # Set breakpoint on this line
    a = subtract(z, y)  # Use Step Out to move to this line
    print(a)

if __name__ == "__main__":
    main()

Evaluating Expressions

The Evaluate Expression window allows you to enter arbitrary expressions and evaluate them in the context of your program. This can help you quickly identify the source of a problem by inspecting variables and their values at different points in your program's execution.

# Example of using the Evaluate Expression window in PyCharm
def main():
    x = 1
    y = 2
    z = x + y  # Set breakpoint on this line
    print(z)  # Open Evaluate Expression window and enter "x + y"

if __name__ == "__main__":
    main()

Conclusion

The PyCharm Debugger is a powerful tool that can help you debug your code quickly and efficiently. By learning how to use the various debugging features in PyCharm, you can save a lot of time and effort in the debugging process. Set breakpoints at critical points in your code, use Step Over to step through your code line by line, and use the Evaluate Expression window to inspect variables and their values. With the PyCharm Debugger, debugging code has never been easier.

As a software engineer, I had the privilege of working on a groundbreaking project at the Urban and Underground Space Laboratory at Qingdao University of Technology. Our team's primary objective was to develop a safety monitoring and evaluation system for shield tunneling, a critical aspect of the construction industry that ensures the safety of workers and materials during tunnel construction projects.

Project Overview

Tunnel construction projects have become increasingly popular in recent years, and with this growth comes the need for robust safety measures. Our project aimed to meet this challenge by designing a system with three primary modules: data collection, data processing, and data evaluation and analysis.

The data collection module allowed for data input through the system's user interface, which could import data from Excel files. The two categories of input data were tunneling data and composite stratum data. The data collected was categorized into existing and analysis data.

The data processing module took the input data and processed it into torque and thrust units, which were used for analysis and output in the data evaluation and analysis system. The processing system also formed a data analysis library.

The data evaluation and analysis module presented the processed data in the data analysis library through a data analysis graph, which was then used to output the results in a tabular format.

Tech Stack

To develop a reliable and efficient system that met the project's goals and requirements, we used a combination of tools and technologies, including:

• Python 3: For its simplicity, versatility, and data analysis support
• GitHub: For version control and collaboration
• NumPy: For array manipulation and scientific computing capabilities
• Pandas: For powerful data manipulation and analysis capabilities
• Matplotlib: For high-quality data visualization
• Qt: For building the graphical user interface
• Virtualenv: For creating isolated Python environments
• PyInstaller: For packaging Python programs into standalone executable files
• Gettext: For internationalization support
• Yapf: For automatic code formatting

Leveraging these tools and technologies enabled us to create a robust and efficient system that met our project's goals and requirements.

Features that I Implemented

As the project's software engineer, I worked on several advanced features that enhanced the safety monitoring and evaluation system for shield tunneling. These features included:

• Extensive documentation: The system's documentation made it easy to understand and use.
• User-friendly GUI: The system's graphical user interface implemented using the Qt framework made it easy to use, even for non-technical users.
• Internationalization support: The system supported English and Chinese languages.
• Authentication: The system used authentication to ensure security.
• Data modeling and curve fitting: The system used data modeling and curve fitting to identify trends and predict errors.
• Display of math equations and plots: The system displayed math equations and plots for complex calculations and analysis.
• Display of tables within the Qt interface: The system displayed tables within the Qt interface and exported data to Excel files.
• Packaging for several platforms: The system could be packaged for several platforms.
• Trend graph generation: The system generated trend graphs for unit thrust and unit torque.

Project Benefits

The project offered several benefits, including:

• Improved safety: The software monitored and evaluated the safety of shield tunneling, ensuring that any issues were identified and addressed before they became a problem.
• Efficient data analysis: The software's data processing and analysis capabilities made it easy to analyze data and output results in a timely manner.

Conclusion

Developing a safety monitoring and evaluation system for shield tunneling was an exciting project that allowed us to apply our software engineering skills to a real-world problem. With the use of Python, NumPy, Pandas, Matplotlib, and other powerful tools, we were able to design a system that greatly improved the safety and efficiency of tunnel construction projects. This project not only allowed us to contribute to the betterment of the construction industry but also provided us with invaluable experience in applying our software engineering expertise to create practical solutions for complex problems.

Have you ever found yourself playing video games for hours without feeling any pressure, but reading a book for even a short period becomes tedious? This is because of the feedback cycle.

Understanding the Feedback Cycle

The feedback cycle is the time between performing an action and receiving feedback on its results. Video games provide immediate feedback within seconds, making it easy to continue playing for an extended period without feeling any pressure. On the other hand, reading a book has a more extended feedback cycle. It requires time to read and process the information before any feedback can be received, making it difficult to remain engaged in the activity for a prolonged period.

Shortening the Feedback Cycle

Many important things require repetitions or iterations of small actions, each of which contains feedback and correction. Shortening the feedback cycle makes it easier to get started, and with each iteration, there is a continuous improvement in performance. This approach is useful not only for learning but also for many other activities.

The learning cycle comprises reading, thinking, applying, and correcting. Shortening this cycle makes learning easier and more efficient. Perseverance is essential, but it does not determine what we can or cannot learn. The ability to persevere determines how long we can endure a feedback cycle.

Adopting a mindset that prioritizes shortening the feedback cycle can make many things more approachable. For example, taking notes while reading and reviewing them regularly or breaking down a lengthy book into shorter sections and giving oneself feedback after each section can make it easier to remain engaged in the activity.

Conclusion

In summary, the feedback cycle plays a significant role in making an activity feel easy or challenging. By adopting a mindset that prioritizes short feedback cycles, we can approach many activities more efficiently and with less pressure. Shortening the feedback cycle can help improve performance and make an activity more engaging and enjoyable, enabling us to endure it for a longer period.

Medical imaging plays a crucial role in the diagnosis and treatment of various health conditions. Accurate segmentation of the diaphragm from CT images is essential for diagnosing and treating respiratory and related diseases. This article reviews several research papers that propose different approaches for automatic or semi-automatic diaphragm segmentation.

Methodologies

A variety of mathematical and computational methods have been proposed for diaphragm segmentation:

1. 3D active appearance model (2002)

• This mathematical model requires a dataset for training and validation. The heart-diaphragm interface is not considered.

2. Manual modeling using Altair HyperMesh (2006)

3. Automated estimation of the upper surface of the diaphragm in 3-D CT images (2008)

• On each voxel, the normal vector V of the lung surface is calculated. The voxel P on the lung surfaces that satisfies the condition {-(3/4)π < direction of V on P < -(1/4)π} is regarded as the candidate voxel. A thin-plate model is deformed to fit the subsample points on the diaphragmatic lung surface by using a 3D thin-plate spline method.

4. Quadratic surface modeling (2008)

• The shape of the lung is obtained by morphological transformation, and then the lung-diaphragm interface is calculated (no specific elaboration), and finally, the quadratic surface is fitted.

5. Manual segmentation and 3D mesh generation (2008)

• The diaphragm was manually segmented and a 3D mesh generated using Insight SnAP software.

6. Local entropy-based segmentation (2010)

• Does not clarify where the red section stops segmentation.

7. Multiorgan extraction and surface fitting in volumetric CT (2014)

• There is no specific explanation of the 3D ray projection method and no reference to related papers. But Matlab's gridfit surface fitting algorithm is worth trying.

8. Ray projection-based segmentation (2016)

• Refer to Paper 7 (Automatic): 2014-Thoracic cavity segmentation algorithm using multiorgan extraction and surface fitting in volumetric CT

9. Anatomy-based segmentation (2016)

• The algorithm proposed in the paper is unstable. The above figure is a coronal slice arbitrarily selected along the anteroposterior axis (x-axis). If the segment lung-diaphragm interface starts along the horizontal axis (y-axis), the green circles marked in the figure may be misjudged as stops due to gradient change.

10. Patient-specific diaphragm muscle modeling (2018)

• The development of a patient-specific model of the diaphragm muscle began with modification and use of a previously developed automatic segmentation algorithm for 4DCT images in order to segment the diaphragm volume at end exhalation, which coincides with muscle relaxation. The diaphragm volume was converted into a mesh with hexahedral elements using 3D Slicer.

11. Real-time direct diaphragm tracking (2019)

• It is not clear whether to apply the intensity threshold at the 2D or 3D level; further investigation is required.

Strengths and Weaknesses

Each approach has its own set of advantages and limitations. Manual segmentation, as used in Paper 5, can be time-consuming and requires expert knowledge. Automated methods, such as those proposed in Papers 3, 4, 6, 7, 8, and 9, 11 can be faster and more consistent, but may not be as accurate as manual segmentation.

Methods based on specific features or conditions, such as normal vectors, quadratic surfaces, or local entropy, may perform differently depending on the specific CT images being analyzed. Further investigation is needed to compare their performance in different scenarios.

Conclusion

The development of automated or semi-automated segmentation methods for the diaphragm has important implications for the diagnosis and treatment of respiratory and related diseases. Accurate segmentation can aid in surgical planning, radiation therapy, and assessment of lung function and disease progression.

This is Ethan's Blog, a brand new site by Ethan Yu that's just getting started. Things will be up and running here shortly, but you can subscribe in the meantime if you'd like to stay up to date and receive emails when new content is published!